Corrected the handling of toolkit callbacks created by the

"magic::add_dependency" procedure.  The "check" function should always
be called first, followed by the dependencies.  Because otherwise, if
an incorrect value is entered for a device parameter, then it gets
used to calculate dependent values *before* it gets corrected by the
"check" procedure, resulting in an incorrect value being displayed
for the dependent value, even after the bad entry has been corrected.

.github/workflows/canary-matrix.yml

@@ -138,6 +138,8 @@ jobs:
           echo "BUILD_GCC_VERSION=$BUILD_GCC_VERSION" >> $GITHUB_ENV
           echo "BUILD_CLANG_VERSION=$BUILD_CLANG_VERSION" >> $GITHUB_ENV
 
+          sudo apt-get update
+
           if [ -n "$BUILD_GCC_VERSION" ]
           then
             GCCV=$BUILD_GCC_VERSION

.github/workflows/main-aarch64.yml

@@ -33,10 +33,22 @@ jobs:
           cd emsdk
           ./emsdk install latest
           ./emsdk activate latest
+      - name: Emscripten Diagnostic
+        run: |
+          source ./emsdk/emsdk_env.sh
+          echo "===== gcc -dM -E - ====="
+          echo | gcc -dM -E - | sort
+          echo "===== g++ -dM -E - ====="
+          echo | g++ -dM -E - | sort
+          echo "===== emcc -dM -E - ====="
+          echo | emcc -dM -E - | sort
+          echo "===== em++ -dM -E - ====="
+          echo | em++ -dM -E - | sort
       - name: Build
         run: |
           source ./emsdk/emsdk_env.sh
-          emconfigure ./configure --without-cairo --without-opengl --without-x --disable-readline --disable-compression --target=asmjs-unknown-emscripten
+          # The --without and --disable in these build options is due to no WASM library being available for that feature
+          CFLAGS="--std=c17 -D_DEFAULT_SOURCE=1 -DEMSCRIPTEN=1 -g" emconfigure ./configure --without-cairo --without-opengl --without-x --without-tk --without-tcl --disable-readline --disable-compression --target=asmjs-unknown-emscripten
           echo "===== defs.mak ====="
           cat defs.mak
           echo "===== defs.mak ====="

.github/workflows/main.yml

@@ -10,19 +10,6 @@ on:
 
 # A workflow run is made up of one or more jobs that can run sequentially or in parallel
 jobs:
-  vezzal:
-    # The type of runner that the job will run on
-    runs-on: ubuntu-latest
-    # Steps represent a sequence of tasks that will be executed as part of the job
-    steps:
-      - name: Pulling the docker image
-        run: docker pull vezzal/vezzal:v1
-
-      - name: Start the container with the docker image
-        run: docker run -id --name test_magic vezzal/vezzal:v1 bash | exit
-
-      - name: Run the testing on the container and send the mail
-        run: docker exec test_magic /vezzal/test_magic.sh "lankasaicharan123@gmail.com,tim@opencircuitdesign.com" ${{secrets.MAILING_KEY}}
   simple_build_linux:
     runs-on: ubuntu-22.04
     steps:
@@ -45,10 +32,22 @@ jobs:
           cd emsdk
           ./emsdk install latest
           ./emsdk activate latest
+      - name: Emscripten Diagnostic
+        run: |
+          source ./emsdk/emsdk_env.sh
+          echo "===== gcc -dM -E - ====="
+          echo | gcc -dM -E - | sort
+          echo "===== g++ -dM -E - ====="
+          echo | g++ -dM -E - | sort
+          echo "===== emcc -dM -E - ====="
+          echo | emcc -dM -E - | sort
+          echo "===== em++ -dM -E - ====="
+          echo | em++ -dM -E - | sort
       - name: Build
         run: |
           source ./emsdk/emsdk_env.sh
-          emconfigure ./configure --without-cairo --without-opengl --without-x --disable-readline --disable-compression --target=asmjs-unknown-emscripten
+          # The --without and --disable in these build options is due to no WASM library being available for that feature
+          CFLAGS="--std=c17 -D_DEFAULT_SOURCE=1 -DEMSCRIPTEN=1 -g" emconfigure ./configure --without-cairo --without-opengl --without-x --without-tk --without-tcl --disable-readline --disable-compression --target=asmjs-unknown-emscripten
           echo "===== defs.mak ====="
           cat defs.mak
           echo "===== defs.mak ====="

VERSION

@@ -1 +1 @@
-8.3.604
+8.3.636

calma/CalmaRdcl.c

@@ -53,6 +53,7 @@ int calmaNonManhattan;
 int CalmaFlattenLimit = 10;
 int NameConvertErrors = 0;
 bool CalmaRewound = FALSE;
+bool CalmaRecordPaths = FALSE;
 TileTypeBitMask *CalmaMaskHints = NULL;
 
 extern HashTable calmaDefInitHash;
@@ -505,28 +506,33 @@ calmaParseStructure(
 
     if (CalmaReadOnly || predefined)
     {
+	PropertyRecord *proprec;
 	char cstring[1024];
 
-	/* Writing the file position into a string is slow, but */
-	/* it prevents requiring special handling when printing	*/
-	/* out the properties.					*/
-
-	char *fpcopy = (char *)mallocMagic(20);
-	char *fncopy;
-
 	/* Substitute variable for PDK path or ~ for home directory	*/
 	/* the same way that cell references are handled in .mag files.	*/
 	DBPathSubstitute(filename, cstring, cifReadCellDef);
-	fncopy = StrDup(NULL, cstring);
-	sprintf(fpcopy, "%"DLONG_PREFIX"d", (dlong) filepos);
-	DBPropPut(cifReadCellDef, "GDS_START", (ClientData)fpcopy);
 
-	fpcopy = (char *)mallocMagic(20);
+	proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+	proprec->prop_type = PROPERTY_TYPE_DOUBLE;
+	proprec->prop_len = 1;
+	proprec->prop_value.prop_double[0] = filepos;
+	DBPropPut(cifReadCellDef, "GDS_START", (ClientData)proprec);
+
 	filepos = FTELL(calmaInputFile);
-	sprintf(fpcopy, "%"DLONG_PREFIX"d", (dlong) filepos);
-	DBPropPut(cifReadCellDef, "GDS_END", (ClientData)fpcopy);
 
-	DBPropPut(cifReadCellDef, "GDS_FILE", (ClientData)fncopy);
+	proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+	proprec->prop_type = PROPERTY_TYPE_DOUBLE;
+	proprec->prop_len = 1;
+	proprec->prop_value.prop_double[0] = filepos;
+	DBPropPut(cifReadCellDef, "GDS_END", (ClientData)proprec);
+
+	proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) - 7 +
+		strlen(cstring));
+	proprec->prop_type = PROPERTY_TYPE_STRING;
+	proprec->prop_len = 1;
+	strcpy(proprec->prop_value.prop_string, cstring);
+	DBPropPut(cifReadCellDef, "GDS_FILE", (ClientData)proprec);
 
     	if (predefined)
     	{
@@ -783,8 +789,8 @@ calmaElementSref(
     char *filename)
 {
     int nbytes, rtype, cols, rows, nref, n, i, savescale;
-    int xlo, ylo, xhi, yhi, xsep, ysep;
+    int xlo, ylo, xhi, yhi, xsep, ysep, angle;
-    bool madeinst = FALSE;
+    bool madeinst = FALSE, rotated = FALSE;
     char *sname = NULL;
     bool isArray = FALSE;
     bool dolookahead = FALSE;
@@ -984,17 +990,73 @@ calmaElementSref(
 	refarray[2].p_x = refarray[2].p_y = 0;
     }
 
+    /* If the array is given an angle, then the meaning of rows and
+     * columns needs to be swapped for the purpose of ignoring
+     * X or Y values in the case of a 1-row or 1-column entry.
+     */
+    angle = GeoTransAngle(&trans, 0);
+    if ((angle == 90) || (angle == 270) || (angle == -90) || (angle == -270))
+	rotated = TRUE;
+
     /* If this is a cell reference, then we scale to magic coordinates
      * and place the cell in the magic database.  However, if this is
      * a cell to be flattened a la "gds flatten", then we keep the GDS
      * coordinates, and don't scale to the magic database.
+     *
+     * NOTE:  Scaling everything in the middle or reading array data
+     * and then retroactively adjusting the array data read earlier
+     * is problematic, and probably incorrect.
      */
 
+  
+    for (n = 0; n < nref; n++)
+    {
+	savescale = calmaReadScale1;
+
+	/* If there is only one column, then X data in the 2nd or 3rd
+	 * entry is irrelevant.  If there is only one row, then Y data
+	 * in the 2nd or 3rd entry is irrelevant.  Prevent issues caused
+	 * by incorrect/uninitialized data in these positions by ignoring
+	 * them as needed.
+	 */
+
+	if ((n > 0) && ((!rotated && (rows == 1)) || (rotated && (cols == 1))))
+	{
+	    calmaReadX(&refarray[n], 1);
+	    calmaSkipBytes(4);
+	    refarray[n].p_y = refarray[0].p_y;
+	}
+	else if ((n > 0) && ((!rotated && (cols == 1)) || (rotated && (rows == 1))))
+	{
+	    calmaSkipBytes(4);
+	    calmaReadY(&refarray[n], 1);
+	    refarray[n].p_x = refarray[0].p_x;
+	}
+	else
+	    calmaReadPoint(&refarray[n], 1);
+
+	if (savescale != calmaReadScale1)
+	{
+	    /* Scale changed, so update previous points read */
+	    int newscale = calmaReadScale1 / savescale;
+	    for (i = 0; i < n; i++)
+	    {
+		refarray[i].p_x *= newscale;
+		refarray[i].p_y *= newscale;
+	    }
+	}
+
+	if (FEOF(calmaInputFile))
+	    return -1;
+    }
+
+    for (n = 0; n < nref; n++)
+	refunscaled[n] = refarray[n];	// Save for CDFLATGDS cells
+
     for (n = 0; n < nref; n++)
     {
 	savescale = cifCurReadStyle->crs_scaleFactor;
-	calmaReadPoint(&refarray[n], 1);
+
-	refunscaled[n] = refarray[n];	// Save for CDFLATGDS cells
 	refarray[n].p_x = CIFScaleCoord(refarray[n].p_x, COORD_EXACT);
 	if (savescale != cifCurReadStyle->crs_scaleFactor)
 	{
@@ -1015,9 +1077,6 @@ calmaElementSref(
 	    }
 	    refarray[n].p_x *= (savescale / cifCurReadStyle->crs_scaleFactor);
 	}
-
-	if (FEOF(calmaInputFile))
-	    return -1;
     }
 
     /* Skip remainder */

calma/CalmaRdpt.c

@@ -114,6 +114,8 @@ calmaInputRescale(
 /*
  * ----------------------------------------------------------------------------
  *
+ * calmaReadX ---
+ * calmaReadY ---
  * calmaReadPoint ---
  *
  * Read a point from the input.
@@ -132,11 +134,17 @@ calmaInputRescale(
  *	encountered, then everything in the GDS planes is rescaled
  *	to match.
  *
+ * Notes:
+ *	This routine has been split into individual X and Y reads so that
+ *	array data can be read while ignoring offset information when there
+ *	is only one row or column;  otherwise, bad or uninitialized data
+ *	in the record can cause unnecessary and incorrect scaling.
+ *
  * ----------------------------------------------------------------------------
  */
 
 void
-calmaReadPoint(
+calmaReadX(
     Point *p,
     int iscale)
 {
@@ -163,6 +171,15 @@ calmaReadPoint(
 	}
     }
     p->p_x /= calmaReadScale2;
+}
+
+
+void
+calmaReadY(
+    Point *p,
+    int iscale)
+{
+    int rescale;
 
     READI4((p)->p_y);
     p->p_y *= (calmaReadScale1 * iscale);
@@ -188,6 +205,15 @@ calmaReadPoint(
     p->p_y /= calmaReadScale2;
 }
 
+void
+calmaReadPoint(
+    Point *p,
+    int iscale)
+{
+    calmaReadX(p, iscale);
+    calmaReadY(p, iscale);
+}
+
 
 /*
  * ----------------------------------------------------------------------------
@@ -692,7 +718,12 @@ calmaElementPath(void)
 	    }
 	}
 
-	CIFPropRecordPath(cifReadCellDef, pathheadp, TRUE, "path");
+	/* If requested by command option, record the path centerline as a
+	 * property of the cell def.
+	 */
+	if (CalmaRecordPaths)
+	    CIFPropRecordPath(cifReadCellDef, pathheadp, TRUE, "path");
+
 	CIFPaintWirePath(pathheadp, width,
 		(pathtype == CALMAPATH_SQUAREFLUSH || pathtype == CALMAPATH_CUSTOM) ?
 		FALSE : TRUE, plane, CIFPaintTable, (PaintUndoInfo *)NULL);

calma/CalmaWrite.c

@@ -528,7 +528,7 @@ calmaDumpStructure(
 
 	    /* Is view abstract? */
 	    DBPropGet(edef, "LEFview", &isAbstract);
-	    chklibname = (char *)DBPropGet(edef, "GDS_FILE", &isReadOnly);
+	    chklibname = DBPropGetString(edef, "GDS_FILE", &isReadOnly);
 
 	    if (isAbstract && isReadOnly)
 	    {
@@ -738,7 +738,7 @@ calmaFullDump(
      * names in the GDS file do not shadow any names in the database.
      */
 
-    viewopts = (char *)DBPropGet(def, "LEFview", &isAbstract);
+    viewopts = DBPropGetString(def, "LEFview", &isAbstract);
     if ((!isAbstract) || (strcasecmp(viewopts, "no_prefix")))
     {
 	/* Generate a SHORT name for this cell (else it is easy to run into the
@@ -918,7 +918,7 @@ calmaProcessDef(
     DBPropGet(def, "GDS_END", &hasGDSEnd);
     DBPropGet(def, "CIFhier", &needHier);
 
-    filename = (char *)DBPropGet(def, "GDS_FILE", &isReadOnly);
+    filename = DBPropGetString(def, "GDS_FILE", &isReadOnly);
 
     /* When used with "calma addendum true", don't output the read-only	*/
     /* cells.  This makes the library incomplete and dependent on the	*/
@@ -1033,13 +1033,12 @@ calmaProcessDef(
 	}
 	else
 	{
-	    offptr = (char *)DBPropGet(def, "GDS_END", NULL);
+	    cval = DBPropGetDouble(def, "GDS_END", NULL);
-	    sscanf(offptr, "%"DLONG_PREFIX"d", &cval);
 	    cellend = (off_t)cval;
-	    offptr = (char *)DBPropGet(def, "GDS_BEGIN", &oldStyle);
+	    cval = DBPropGetDouble(def, "GDS_BEGIN", &oldStyle);
 	    if (!oldStyle)
 	    {
-		offptr = (char *)DBPropGet(def, "GDS_START", NULL);
+		cval = DBPropGetDouble(def, "GDS_START", NULL);
 
 		/* Write our own header and string name, to ensure	*/
 		/* that the magic cell name and GDS name match.		*/
@@ -1056,7 +1055,6 @@ calmaProcessDef(
 		calmaOutStructName(CALMA_STRNAME, def, outf);
 	    }
 
-	    sscanf(offptr, "%"DLONG_PREFIX"d", &cval);
 	    cellstart = (off_t)cval;
 
 	    /* GDS_START has been defined as the start of data after the cell	*/
@@ -1263,7 +1261,7 @@ calmaOutFunc(
     int dbunits;
     calmaOutputStruct cos;
     bool propfound;
-    char *propvalue;
+    PropertyRecord *proprec;
 
     cos.f = f;
     cos.area = (cliprect == &TiPlaneRect) ? NULL : cliprect;
@@ -1323,14 +1321,20 @@ calmaOutFunc(
 
     /* Include any fixed bounding box as part of the area to process,	*/
     /* in case the fixed bounding box is larger than the geometry.	*/
-    propvalue = (char *)DBPropGet(def, "FIXED_BBOX", &propfound);
+    proprec = DBPropGet(def, "FIXED_BBOX", &propfound);
     if (propfound)
     {
 	Rect bbox;
 
-        if (sscanf(propvalue, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
+	if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
-                &bbox.r_xtop, &bbox.r_ytop) == 4)
+			(proprec->prop_len == 4))
+	{
+	    bbox.r_xbot = proprec->prop_value.prop_integer[0];
+	    bbox.r_ybot = proprec->prop_value.prop_integer[1];
+	    bbox.r_xtop = proprec->prop_value.prop_integer[2];
+	    bbox.r_ytop = proprec->prop_value.prop_integer[3];
 	    GeoInclude(&bbox, &bigArea);
+	}
     }
 
     CIFErrorDef = def;

calma/CalmaWriteZ.c

@@ -508,7 +508,7 @@ calmaDumpStructureZ(
 
 	    /* Is view abstract? */
 	    DBPropGet(edef, "LEFview", &isAbstract);
-	    chklibname = (char *)DBPropGet(edef, "GDS_FILE", &isReadOnly);
+	    chklibname = DBPropGetString(edef, "GDS_FILE", &isReadOnly);
 
 	    if (isAbstract && isReadOnly)
 	    {
@@ -716,7 +716,7 @@ calmaFullDumpZ(
      * names in the GDS file do not shadow any names in the database.
      */
 
-    viewopts = (char *)DBPropGet(def, "LEFview", &isAbstract);
+    viewopts = DBPropGetString(def, "LEFview", &isAbstract);
     if ((!isAbstract) || (strcasecmp(viewopts, "no_prefix")))
     {
 	/* Generate a SHORT name for this cell (else it is easy to run into the
@@ -870,7 +870,7 @@ calmaProcessDefZ(
     DBPropGet(def, "GDS_START", &hasContent);
     DBPropGet(def, "GDS_END", &hasGDSEnd);
     DBPropGet(def, "CIFhier", &needHier);
-    filename = (char *)DBPropGet(def, "GDS_FILE", &isReadOnly);
+    filename = DBPropGetString(def, "GDS_FILE", &isReadOnly);
 
     /* When used with "calma addendum true", don't output the read-only	*/
     /* cells.  This makes the library incomplete and dependent on the	*/
@@ -985,13 +985,12 @@ calmaProcessDefZ(
 	}
 	else
 	{
-	    offptr = (char *)DBPropGet(def, "GDS_END", NULL);
+	    cval = DBPropGetDouble(def, "GDS_END", NULL);
-	    sscanf(offptr, "%"DLONG_PREFIX"d", &cval);
 	    cellend = (z_off_t)cval;
-	    offptr = (char *)DBPropGet(def, "GDS_BEGIN", &oldStyle);
+	    cval = DBPropGetDouble(def, "GDS_BEGIN", &oldStyle);
 	    if (!oldStyle)
 	    {
-		offptr = (char *)DBPropGet(def, "GDS_START", NULL);
+		cval = DBPropGetDouble(def, "GDS_START", NULL);
 
 		/* Write our own header and string name, to ensure	*/
 		/* that the magic cell name and GDS name match.		*/
@@ -1008,7 +1007,6 @@ calmaProcessDefZ(
 		calmaOutStructNameZ(CALMA_STRNAME, def, outf);
 	    }
 
-	    sscanf(offptr, "%"DLONG_PREFIX"d", &cval);
 	    cellstart = (z_off_t)cval;
 
 	    /* GDS_START has been defined as the start of data after the cell	*/
@@ -1186,6 +1184,7 @@ calmaOutFuncZ(
     int dbunits;
     calmaOutputStructZ cos;
     bool propfound;
+    PropertyRecord *proprec;
     char *propvalue;
     extern int compport(const void *one, const void *two);	/* Forward declaration */
 
@@ -1247,14 +1246,20 @@ calmaOutFuncZ(
 
     /* Include any fixed bounding box as part of the area to process,	*/
     /* in case the fixed bounding box is larger than the geometry.	*/
-    propvalue = (char *)DBPropGet(def, "FIXED_BBOX", &propfound);
+    proprec = DBPropGet(def, "FIXED_BBOX", &propfound);
     if (propfound)
     {
 	Rect bbox;
 
-	if (sscanf(propvalue, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
+	if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
-		&bbox.r_xtop, &bbox.r_ytop) == 4)
+		(proprec->prop_len == 4))
+	{
+	    bbox.r_xbot = proprec->prop_value.prop_integer[0];
+	    bbox.r_ybot = proprec->prop_value.prop_integer[1];
+	    bbox.r_xtop = proprec->prop_value.prop_integer[2];
+	    bbox.r_ytop = proprec->prop_value.prop_integer[3];
 	    GeoInclude(&bbox, &bigArea);
+	}
     }
 
     CIFErrorDef = def;

calma/calma.h

@@ -38,6 +38,7 @@ extern TileTypeBitMask *CalmaMaskHints;
 extern bool CalmaMergeTiles;
 extern bool CalmaFlattenArrays;
 extern bool CalmaNoDRCCheck;
+extern bool CalmaRecordPaths;
 extern bool CalmaFlattenUses;
 extern int  CalmaFlattenLimit;
 extern float CalmaMagScale;
@@ -81,6 +82,8 @@ extern int calmaProcessDefZ(CellDef *def, gzFile outf, bool do_library);
 #endif
 extern bool calmaReadI2Record(int type, int *pvalue);
 extern bool calmaReadI4Record(int type, int *pvalue);
+extern void calmaReadX(Point *p, int iscale);
+extern void calmaReadY(Point *p, int iscale);
 extern void calmaReadPoint(Point *p, int iscale);
 extern bool calmaReadR8(double *pd);
 extern bool calmaReadStampRecord(int type, int *stampptr);

cif/CIFgen.c

@@ -25,6 +25,7 @@ static const char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magi
 #include <stdlib.h>             /* for abs() */
 #include <math.h>		/* for ceil() and sqrt() */
 #include <ctype.h>
+#include <string.h>		/* for strcmp() */
 
 #include "utils/magic.h"
 #include "utils/geometry.h"
@@ -1500,6 +1501,7 @@ cifBloatAllFunc(
 
     while (!StackEmpty(BloatStack))
     {
+	Rect cifarea;
 	TileType tt;
 
 	POPTILE(t, dinfo, BloatStack);
@@ -1516,8 +1518,6 @@ cifBloatAllFunc(
 
 	if (op->co_distance > 0)
 	{
-	    Rect cifarea;
-
 	    cifarea.r_xbot = area.r_xbot;
 	    cifarea.r_ybot = area.r_ybot;
 	    cifarea.r_xtop = area.r_xtop;
@@ -1555,40 +1555,42 @@ cifBloatAllFunc(
 	{
 	    tt = TiGetTypeExact(t);
 	    if (op->co_distance > 0)
-		GeoClip(&area, &clipArea);
+		DBNMPaintPlane(cifPlane, TiGetTypeExact(t), &cifarea,
-	    DBNMPaintPlane(cifPlane, TiGetTypeExact(t), &area,
+			CIFPaintTable, (PaintUndoInfo *) NULL);
+	    else
+		DBNMPaintPlane(cifPlane, TiGetTypeExact(t), &area,
 			CIFPaintTable, (PaintUndoInfo *) NULL);
 	}
 
 	/* Top */
-	for (tp = RT(t); RIGHT(tp) > LEFT(t); tp = BL(tp))
+	if ((op->co_distance == 0) || (area.r_ytop < clipArea.r_ytop))
-	    if (TTMaskHasType(connect, TiGetBottomType(tp)))
+	    for (tp = RT(t); RIGHT(tp) > LEFT(t); tp = BL(tp))
-		PUSHTILE(tp,
+		if (TTMaskHasType(connect, TiGetBottomType(tp)))
-			(SplitDirection(tp) == ((tt & TT_DIRECTION) ? 1 : 0)) ?
+		    PUSHTILE(tp, (SplitDirection(tp) == ((tt & TT_DIRECTION) ? 1 : 0)) ?
-			(TileType)0 : (TileType)TT_SIDE,
+				(TileType)0 : (TileType)TT_SIDE, BloatStack);
-			BloatStack);
 
 	/* Left */
-	for (tp = BL(t); BOTTOM(tp) < TOP(t); tp = RT(tp))
+	if ((op->co_distance == 0) || (area.r_xbot > clipArea.r_xbot))
-	    if (TTMaskHasType(connect, TiGetRightType(tp)))
+	    for (tp = BL(t); BOTTOM(tp) < TOP(t); tp = RT(tp))
-		PUSHTILE(tp, (TileType)TT_SIDE, BloatStack);
+		if (TTMaskHasType(connect, TiGetRightType(tp)))
+		    PUSHTILE(tp, (TileType)TT_SIDE, BloatStack);
 
 	/* Bottom */
-	for (tp = LB(t); LEFT(tp) < RIGHT(t); tp = TR(tp))
+	if ((op->co_distance == 0) || (area.r_ybot > clipArea.r_ybot))
-	    if (TTMaskHasType(connect, TiGetTopType(tp)))
+	    for (tp = LB(t); LEFT(tp) < RIGHT(t); tp = TR(tp))
-		PUSHTILE(tp,
+		if (TTMaskHasType(connect, TiGetTopType(tp)))
-			(SplitDirection(tp) == ((tt & TT_DIRECTION) ? 1 : 0)) ?
+		    PUSHTILE(tp, (SplitDirection(tp) == ((tt & TT_DIRECTION) ? 1 : 0)) ?
-			(TileType)TT_SIDE : (TileType)0,
+				(TileType)TT_SIDE : (TileType)0, BloatStack);
-			BloatStack);
 
 	/* Right */
-	for (tp = TR(t); TOP(tp) > BOTTOM(t); tp = LB(tp))
+	if ((op->co_distance == 0) || (area.r_xtop < clipArea.r_xtop))
-	    if (TTMaskHasType(connect, TiGetLeftType(tp)))
+	    for (tp = TR(t); TOP(tp) > BOTTOM(t); tp = LB(tp))
-		PUSHTILE(tp, (TileType)0, BloatStack);
+		if (TTMaskHasType(connect, TiGetLeftType(tp)))
+		    PUSHTILE(tp, (TileType)0, BloatStack);
     }
 
     /* Clear self */
-    TiSetClient(tile, CIF_UNPROCESSED);
+    // TiSetClient(tile, CIF_UNPROCESSED);
 
     /* NOTE:  Tiles must be cleared after the bloat-all function has
      * completed.  However, for bloat-all with a limiting distance,
@@ -4458,14 +4460,16 @@ bridgeErase(
 	maskBits = DBPlaneTypes[i];
 	TTMaskAndMask(&maskBits, &brlims->co_paintMask);
 	if (!TTMaskEqual(&maskBits, &DBZeroTypeBits))
-	    if (DBSrPaintArea((Tile *) NULL, brlims->def->cd_planes[i], area, &brlims->co_paintMask, cifPaintFunc, CIFEraseTable))
+	    if (DBSrPaintArea((Tile *) NULL, brlims->def->cd_planes[i],
+			area, &brlims->co_paintMask, cifPaintFunc, CIFEraseTable))
 		return 0;
     }
 
     for (t = 0; t < TT_MAXTYPES; t++, temps++)
     {
         if (TTMaskHasType(&brlims->co_cifMask, t))
-           if (DBSrPaintArea((Tile *) NULL, *temps, area, &CIFSolidBits, cifPaintFunc, CIFEraseTable))
+           if (DBSrPaintArea((Tile *) NULL, *temps, area, &CIFSolidBits,
+			cifPaintFunc, CIFEraseTable))
                 return 0;
     }
 
@@ -4766,6 +4770,106 @@ cifBridgeLimFunc2(
     return 0;
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * cifNotSquareFunc --
+ *
+ *	Process each tile and remove those which are square and not
+ *	connected to any other tile of the same type.  This operator aids
+ *	in the detection of bar contacts to distinguish them from regular
+ *	(square) contact cuts.  Because of the special nature of the
+ *	operator, only the negative-sense operator "not-square" is
+ *	implemented, as the positive-sense operator is not especially
+ *	useful (and can be implemented if needed with "not-square" and
+ *	"and-not"). 
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Modifies the CIF planes.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+int
+cifNotSquareFunc(
+    Tile *tile,
+    TileType dinfo,
+    ClientData clientData)		/* (unused) */
+{
+    Tile *tp;
+    TileType ttype;
+    Rect area;
+    int width, height;
+    bool isolated = TRUE;
+
+    if (IsSplit(tile)) return 0;	/* Non-Manhattan tiles are never square */
+    ttype = TiGetType(tile);
+    if (ttype == TT_SPACE) return 0;	/* Don't handle space tiles */
+
+    /* Search all four sides of the tile.  Tiles are only considered square
+     * for the purposes of this operator if they are also unconnected to any
+     * other tile.
+     */
+
+    /* Top */
+    for (tp = RT(tile); RIGHT(tp) > LEFT(tile); tp = BL(tp))
+	if (TiGetBottomType(tp) == ttype)
+	{
+	    isolated = FALSE;
+	    break;
+	}
+
+    /* Left */
+    if (isolated)
+	for (tp = BL(tile); BOTTOM(tp) < TOP(tile); tp = RT(tp))
+	    if (TiGetBottomType(tp) == ttype)
+	    {
+		isolated = FALSE;
+		break;
+	    }
+
+    /* Bottom */
+    if (isolated)
+	for (tp = LB(tile); LEFT(tp) < RIGHT(tile); tp = TR(tp))
+	    if (TiGetBottomType(tp) == ttype)
+	    {
+		isolated = FALSE;
+		break;
+	    }
+
+    /* Right */
+    if (isolated)
+	for (tp = TR(tile); TOP(tp) > BOTTOM(tile); tp = LB(tp))
+	    if (TiGetBottomType(tp) == ttype)
+	    {
+		isolated = FALSE;
+		break;
+	    }
+
+    TiToRect(tile, &area);
+
+    if (isolated)
+    {
+	width = area.r_xtop - area.r_xbot;
+	height = area.r_ytop - area.r_ybot;
+	if (width == height) return 0;		/* Square and isolated */
+    }
+
+    area.r_xbot *= cifScale;
+    area.r_ybot *= cifScale;
+    area.r_xtop *= cifScale;
+    area.r_ytop *= cifScale;
+
+    DBPaintPlane(cifPlane, &area, CIFPaintTable, (PaintUndoInfo *)NULL);
+
+    CIFTileOps += 1;
+    return 0;
+}
+
+
 /*
  * ----------------------------------------------------------------------------
  *
@@ -4779,6 +4883,7 @@ cifBridgeLimFunc2(
  *	None.
  *
  * Side effects:
+ *	Modifies the CIF planes.
  *
  * ----------------------------------------------------------------------------
  */
@@ -4940,6 +5045,47 @@ cifInteractingRegions(
     }
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * cifCopyPropPlaneFunc --
+ *
+ * 	Copy the contents of a plane saved as a plane-type property into the
+ *	current CIF plane.  The property plane is in magic internal
+ *	coordinates, so each tile needs to be scaled and redrawn into the
+ *	current CIF plane.
+ *
+ * Results:
+ *	Zero to keep the search going
+ *
+ * Side effects:
+ *	Copies translated geometry into the target plane.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+int
+cifCopyPropPlaneFunc(Tile *tile,
+    TileType dinfo,
+    Plane *curPlane)
+{
+    Rect bbox;
+
+    TiToRect(tile, &bbox);
+
+    cifScale = (CIFCurStyle) ? CIFCurStyle->cs_scaleFactor : 1;
+
+    bbox.r_xbot *= cifScale;
+    bbox.r_ybot *= cifScale;
+    bbox.r_xtop *= cifScale;
+    bbox.r_ytop *= cifScale;
+
+    cifScale = 1;
+    DBNMPaintPlane(curPlane, CIF_SOLIDTYPE, &bbox,
+		CIFPaintTable, (PaintUndoInfo *)NULL);
+    return 0;
+}
+
 /*
  * ----------------------------------------------------------------------------
  *
@@ -4991,13 +5137,15 @@ CIFGenLayer(
     CIFSquaresInfo csi;
     SearchContext scx;
     TileType ttype;
-    char *netname;
+    char *netname, *text;
+    Label *label;
     BloatStruct bls;
     BridgeStruct brs;
     BridgeLimStruct brlims;
     BridgeData *bridge;
-    BloatData *bloats;
+    BloatData *bloats, locbloat;
     bool hstop = FALSE;
+    PropertyRecord *proprec;
     char *propvalue;
     bool found;
 
@@ -5314,9 +5462,12 @@ CIFGenLayer(
 				    (ClientData)NULL);
 	        }
 	        else
+		{
+		    TTMaskSetMask(&bls.connect, &op->co_paintMask);
 		    DBSrPaintArea((Tile *)NULL, cellDef->cd_planes[bloats->bl_plane],
 			    &TiPlaneRect, &bls.connect, cifProcessResetFunc,
 			    (ClientData)NULL);
+		}
 
 		break;
 
@@ -5395,7 +5546,6 @@ CIFGenLayer(
 		nextPlane = temp;
 		break;
 
-
 	    case CIFOP_MAXRECT:
 		cifPlane = curPlane;
 
@@ -5418,6 +5568,19 @@ CIFGenLayer(
 		nextPlane = temp;
 		break;
 
+	    case CIFOP_NOTSQUARE:
+		DBClearPaintPlane(nextPlane);
+		cifPlane = nextPlane;
+		cifScale = 1;
+		DBSrPaintArea((Tile *) NULL, curPlane, &TiPlaneRect,
+		    	&CIFSolidBits, cifNotSquareFunc,
+			(ClientData)NULL);
+
+		temp = curPlane;
+		curPlane = nextPlane;
+		nextPlane = temp;
+		break;
+
 	    case CIFOP_NET:
 		if (hier)
 		{
@@ -5443,6 +5606,108 @@ CIFGenLayer(
 		}
 		break;
 
+	    case CIFOP_TAGGED:
+		if (hier)
+		{
+		    hstop = TRUE;	/* Stop hierarchical processing */
+		    break;
+		}
+
+		/*
+		 * Find all relevant labels by text matching and then continue
+		 * like CIFOP_BLOATALL.  CIFOP_BLOATALL uses a BloatData record
+		 * which is not part of CIFOP_TAGGED.  Create a BloatData record
+		 * on the fly for each tagged area based on type, and swap it for
+		 * the text, so that cifBloatAllFunc believes this is actually a
+		 * CIFOP_BLOATALL operation.  Note that we don't actually care
+		 * what layer the label is attached to (lab_type).  We are looking
+		 * for labels whose lab_rect values overlap the types that are given
+		 * in the rule.
+		 */
+
+		cifPlane = curPlane;
+		bls.op = op;
+		bls.def = cellDef;
+		bls.temps = temps;
+
+		text = (char *)op->co_client;
+
+	        bloats = &locbloat;
+		if (!TTMaskIsZero(&op->co_cifMask))
+		{
+		    bloats->bl_plane = -1;
+		    for (ttype = 0; ttype < TT_MAXTYPES; ttype++)
+		    {
+			if (TTMaskHasType(&op->co_cifMask, ttype))
+		    	    bloats->bl_distance[ttype] = 1;
+			else
+		    	    bloats->bl_distance[ttype] = 0;
+		    }
+		}
+		else if (!TTMaskIsZero(&op->co_paintMask))
+		{
+		    int plane, pmask;
+		    pmask = DBTechTypesToPlanes(&op->co_paintMask);
+		    for (plane = PL_TECHDEPBASE; plane < DBNumPlanes; plane++)
+			if (PlaneMaskHasPlane(pmask, plane))
+			    break;
+		    bloats->bl_plane = plane;
+		    for (ttype = 0; ttype < TT_MAXTYPES; ttype++)
+		    {
+			if (TTMaskHasType(&op->co_paintMask, ttype))
+		    	    bloats->bl_distance[ttype] = 1;
+			else
+		    	    bloats->bl_distance[ttype] = 0;
+		    }
+		}
+
+		/* Replace the client data with the bloat record */
+		op->co_client = (ClientData)bloats;
+
+	        if (bloats->bl_plane < 0)
+	        {
+		   /* bl_plane == -1 indicates bloating into a CIF templayer,	*/
+		   /* so the only connecting type should be CIF_SOLIDTYPE.	*/
+		   TTMaskSetOnlyType(&bls.connect, CIF_SOLIDTYPE);
+	        }
+	        else
+	        {
+		    int i;
+		    TTMaskZero(&bls.connect);
+		    for (i = 0; i < TT_MAXTYPES; i++)
+			if (bloats->bl_distance[i] != 0)
+			  TTMaskSetType(&bls.connect, i);
+	        }
+
+		for (label = cellDef->cd_labels; label; label = label->lab_next)
+		    if (!strcmp(label->lab_text, text))
+			cifSrTiles(op, &label->lab_rect, cellDef, temps,
+				cifBloatAllFunc, (ClientData)&bls);
+
+	        /* Reset marked tiles */
+
+	        if (bloats->bl_plane < 0)   /* Bloat types are CIF types */
+	        {
+		    bls.temps = temps;
+		    for (ttype = 0; ttype < TT_MAXTYPES; ttype++, bls.temps++)
+			if (bloats->bl_distance[ttype] > 0)
+			    (void) DBSrPaintArea((Tile *)NULL, *bls.temps, &TiPlaneRect,
+				    &CIFSolidBits, cifProcessResetFunc,
+				    (ClientData)NULL);
+	        }
+	        else
+		{
+		    TTMaskSetMask(&bls.connect, &op->co_paintMask);
+		    DBSrPaintArea((Tile *)NULL, cellDef->cd_planes[bloats->bl_plane],
+			    &TiPlaneRect, &bls.connect, cifProcessResetFunc,
+			    (ClientData)NULL);
+		}
+
+		/* Replace the client data */
+		op->co_client = (ClientData)text;
+
+		break;
+
 	    case CIFOP_BOUNDARY:
 		if (hier)
 		{
@@ -5454,10 +5719,17 @@ CIFGenLayer(
 
 		if (origDef && (origDef->cd_flags & CDFIXEDBBOX))
 		{
-		    propvalue = (char *)DBPropGet(origDef, "FIXED_BBOX", &found);
+		    proprec = DBPropGet(origDef, "FIXED_BBOX", &found);
 		    if (!found) break;
-		    if (sscanf(propvalue, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
+
-				&bbox.r_xtop, &bbox.r_ytop) != 4) break;
+		    if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
+				(proprec->prop_len == 4))
+		    {
+			bbox.r_xbot = proprec->prop_value.prop_integer[0];
+			bbox.r_ybot = proprec->prop_value.prop_integer[1];
+			bbox.r_xtop = proprec->prop_value.prop_integer[2];
+			bbox.r_ytop = proprec->prop_value.prop_integer[3];
+		    }
 
 		    cifScale = (CIFCurStyle) ? CIFCurStyle->cs_scaleFactor : 1;
 		    bbox.r_xbot *= cifScale;
@@ -5519,46 +5791,22 @@ CIFGenLayer(
 
 	    case CIFOP_MASKHINTS:
 		{
-		    int j, numfound;
+		    int n;
 		    char propname[512];
-		    char *propptr;
 		    char *layername = (char *)op->co_client;
+		    Tile *t;
 
-		    sprintf(propname, "MASKHINTS_%s", layername);
+		    snprintf(propname, 512, "MASKHINTS_%s", layername);
 		    
-		    propvalue = (char *)DBPropGet(cellDef, propname, &found);
+		    if (cellDef == (CellDef *)NULL) break;
+		    proprec = DBPropGet(cellDef, propname, &found);
 		    if (!found) break;	    /* No mask hints available */
-		    propptr = propvalue;
-		    while (*propptr)
-		    {
-			numfound = sscanf(propptr, "%d %d %d %d",
-				&bbox.r_xbot, &bbox.r_ybot,
-				&bbox.r_xtop, &bbox.r_ytop);
 
-			if (numfound != 4)
+		    ASSERT (proprec->prop_type == PROPERTY_TYPE_PLANE, "CIFGenLayer");
-			{
+		    t = PlaneGetHint(proprec->prop_value.prop_plane);
-			    /* To do:  Allow keyword "rect", "tri", or "poly"
+		    DBSrPaintArea(t, proprec->prop_value.prop_plane,
-			     * at the start of the list and parse accordingly.
+				&TiPlaneRect, &CIFSolidBits,
-			     * For now, this only flags an error.
+				cifCopyPropPlaneFunc, (ClientData)curPlane);
-			     */
-			    TxError("%s:  Cannot read rectangle values.\n", propname);
-			    break;
-			}
-			cifPlane = curPlane;
-			cifScale = (CIFCurStyle) ? CIFCurStyle->cs_scaleFactor : 1;
-			bbox.r_xbot *= cifScale;
-			bbox.r_xtop *= cifScale;
-			bbox.r_ybot *= cifScale;
-			bbox.r_ytop *= cifScale;
-			cifScale = 1;
-			DBNMPaintPlane(curPlane, CIF_SOLIDTYPE, &bbox,
-				CIFPaintTable, (PaintUndoInfo *)NULL);
-			for (j = 0; j < 4; j++)
-			{
-			    while (*propptr && isspace(*propptr)) propptr++;
-			    while (*propptr && !isspace(*propptr)) propptr++;
-			}
-		    }
 		}
 		break;
 

cif/CIFhier.c

@@ -209,52 +209,41 @@ typedef struct _maskHintsData
 {
     Transform *mh_trans;
     CellDef *mh_def;
+    Plane *mh_plane;
 } MaskHintsData;
 
 /*
  * ----------------------------------------------------------------------------
  *
- * cifMaskHints --
+ * cifCopyMaskHintFunc --
  *
- *	Copy a mask hint into a target cell by adding it to the
+ *	Callback function used by cifFlatMaskHints.  Transforms a tile
- *	property list of the target cell.  If the target cell already
+ *	from the original plane and paints it into the target plane,
- *	has the same mask hint key, then the mask hint value is
+ *	both of which are properties.
- *	appended to the property in the target cell def.
  *
- * Returns:
+ * Results:
- *	0 to keep the search going.
+ *	Zero to keep the search going.
  *
  * Side effects:
- *	Modifies properties of the target cell def.
+ *	Paints geometry into the target plane.
  *
  * ----------------------------------------------------------------------------
  */
 
-/* DEPRECATED */
 int
-cifMaskHints(
+cifCopyMaskHintFunc(Tile *tile,
-    char *name,
+    TileType dinfo,
-    char *value,
+    ClientData cdata)
-    CellDef *targetDef)
 {
-    char *propvalue, *newval;
+    MaskHintsData *mhd = (MaskHintsData *)cdata;
-    bool propfound;
+    Rect r, newr;
 
-    if (!strncmp(name, "MASKHINTS_", 10))
+    TiToRect(tile, &r);
-    {
+
-	/* Check if name exists already in the flattened cell */
+    /* Transform tile area to coordinates of mhd->mh_plane and paint */
-	propvalue = (char *)DBPropGet(targetDef, name, &propfound);
+    GeoTransRect(mhd->mh_trans, &r, &newr);
-	if (propfound)
+    DBPaintPlane(mhd->mh_plane, &newr, CIFPaintTable, (PaintUndoInfo *)NULL);
-	{
-	    /* Append value to the property */
-	    newval = mallocMagic(strlen(value) + strlen(propvalue) + 2);
-	    sprintf(newval, "%s %s", propvalue, value);
-	}
-	else
-	    newval = StrDup((char **)NULL, value);
 
-	DBPropPut(targetDef, name, newval);
-    }
     return 0;
 }
 
@@ -264,8 +253,8 @@ cifMaskHints(
  * cifFlatMaskHints --
  *
  *	Copy a mask hint into a flattened cell by transforming it into the
- *	coordinate system of the flattened cell, and adding it to the
+ *	coordinate system of the flattened cell, and painting it into the
- *	property list of the flattened cell.
+ *	property plane of the flattened cell.
  *
  * Returns:
  *	0 to keep the search going.
@@ -279,67 +268,40 @@ cifMaskHints(
 int
 cifFlatMaskHints(
     char *name,
-    char *value,
+    PropertyRecord *proprec,
     MaskHintsData *mhd)
 {
     Rect r, newr;
     char *vptr, *newval, *lastval, *propvalue;
     bool propfound;
-    int lastlen, numvals;
+    int i, lastlen, numvals;
+    PropertyRecord *newproprec, *oldproprec;
+    Plane *plane;
 
     if (!strncmp(name, "MASKHINTS_", 10))
     {
-	newval = (char *)NULL;
-	vptr = value;
-	while (*vptr != '\0')
-	{
-	    numvals = sscanf(vptr, "%d %d %d %d", &r.r_xbot, &r.r_ybot,
-			&r.r_xtop, &r.r_ytop);
-	    if (numvals == 4)
-	    {
-		/* Transform rectangle to top level coordinates */
-		GeoTransRect(mhd->mh_trans, &r, &newr);
-		lastval = newval;
-		lastlen = (lastval) ? strlen(lastval) : 0;
-		newval = mallocMagic(40 + lastlen);
-		if (lastval)
-		    strcpy(newval, lastval);
-		else
-		    *newval = '\0';
-		sprintf(newval + lastlen, "%s%d %d %d %d", (lastval) ? " " : "",
-			newr.r_xbot, newr.r_ybot, newr.r_xtop, newr.r_ytop);
-		if (lastval) freeMagic(lastval);
-
-		/* Parse through the four values and check if there's more */
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-	    }
-	    else
-	    {
-		TxError("MASKHINTS_%s:  Expected 4 values, found only %d\n",
-				name + 10, numvals);
-		break;
-	    }
-	}
-
 	/* Check if name exists already in the flattened cell */
-	propvalue = (char *)DBPropGet(mhd->mh_def, name, &propfound);
+	oldproprec = (PropertyRecord *)DBPropGet(mhd->mh_def, name, &propfound);
 	if (propfound)
 	{
-	    /* Append newval to the property */
+	    ASSERT(oldproprec->prop_value.prop_type == PROPERTY_TYPE_PLANE, 
-	    lastval = newval;
+			"cifFlatMaskHints");
-	    newval = mallocMagic(strlen(lastval) + strlen(propvalue) + 2);
+	    plane = oldproprec->prop_value.prop_plane;
-	    sprintf(newval, "%s %s", propvalue, lastval);
-	    freeMagic(lastval);
 	}
-	DBPropPut(mhd->mh_def, name, newval);
+	else
+	{
+	    newproprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+	    newproprec->prop_len = 0; 	/* (unused) */
+	    newproprec->prop_type = PROPERTY_TYPE_PLANE;
+	    plane = DBNewPlane((ClientData)TT_SPACE);
+	    newproprec->prop_value.prop_plane = plane;
+	    DBPropPut(mhd->mh_def, name, newproprec);
+	}
+
+	mhd->mh_plane = plane;
+	DBSrPaintArea((Tile *)NULL, proprec->prop_value.prop_plane,
+			&TiPlaneRect, &CIFSolidBits,
+			cifCopyMaskHintFunc, (ClientData)mhd);
     }
     return 0;
 }
@@ -350,9 +312,10 @@ cifFlatMaskHints(
  * CIFCopyMaskHints --
  *
  *	Callback function to copy mask hints from one cell into another.
+ *	(Occasionally called as a standalone function, not as a callback.)
  * 
  * Results:
- *	None.
+ *	Return 0 to keep the search going.
  *
  * Side effects:
  *	May modify properties in the target cell.
@@ -360,7 +323,7 @@ cifFlatMaskHints(
  * ----------------------------------------------------------------------------
  */
 
-void
+int
 CIFCopyMaskHints(
     SearchContext *scx,
     CellDef *targetDef)
@@ -370,38 +333,9 @@ CIFCopyMaskHints(
     CellDef *sourceDef = scx->scx_use->cu_def;
     mhd.mh_trans = &scx->scx_trans;
     mhd.mh_def = targetDef;
+    mhd.mh_plane = (Plane *)NULL;
 
     DBPropEnum(sourceDef, cifFlatMaskHints, &mhd);
-}
-
-/*
- * ----------------------------------------------------------------------------
- *
- * cifHierCopyMaskHints --
- *
- *	Callback function to copy mask hints from a subcell into a flattened
- *	cell, which is passed in the clientData record.
- * 
- * Results:
- *	Always returns 0 to keep the search alive.
- *
- * Side effects:
- *	May modify properties in the flattened cell.
- *
- * ----------------------------------------------------------------------------
- */
-
-int
-cifHierCopyMaskHints(
-    SearchContext *scx,
-    ClientData clientData)
-{
-    MaskHintsData mhd;
-
-    mhd.mh_trans = &scx->scx_trans;
-    mhd.mh_def = (CellDef *)clientData;
-
-    DBPropEnum(scx->scx_use->cu_def, cifFlatMaskHints, &mhd);
     return 0;
 }
 
@@ -526,7 +460,7 @@ cifHierCellFunc(
 
     /* Flatten mask hints in the area of interest */
     CIFCopyMaskHints(scx, CIFComponentDef);
-    DBTreeSrCells(&newscx, 0, cifHierCopyMaskHints,
+    DBTreeSrCells(&newscx, 0, CIFCopyMaskHints,
 		(ClientData)CIFComponentDef);
 
     /* Set CIFErrorDef to NULL to ignore errors here... these will
@@ -854,7 +788,7 @@ CIFGenSubcells(
 		cifHierCopyFunc, (ClientData) CIFTotalDef);
 	    /* Flatten mask hints in the area of interest */
     	    CIFCopyMaskHints(&scx, CIFTotalDef);
-	    DBTreeSrCells(&scx, 0, cifHierCopyMaskHints,
+	    DBTreeSrCells(&scx, 0, CIFCopyMaskHints,
                 	(ClientData)CIFTotalDef);
 
 	    CIFErrorDef = def;
@@ -1032,14 +966,14 @@ cifHierElementFunc(
     (void) DBTreeSrTiles(&scx, &CIFCurStyle->cs_yankLayers, 0,
 	cifHierCopyFunc, (ClientData) CIFTotalDef);
     CIFCopyMaskHints(&scx, CIFTotalDef);
-    DBTreeSrCells(&scx, 0, cifHierCopyMaskHints,
+    DBTreeSrCells(&scx, 0, CIFCopyMaskHints,
                 (ClientData)CIFTotalDef);
 
     DBCellClearDef(CIFComponentDef);
     (void) DBTreeSrTiles(&scx, &CIFCurStyle->cs_yankLayers, 0,
 	cifHierCopyFunc, (ClientData) CIFComponentDef);
     CIFCopyMaskHints(&scx, CIFComponentDef);
-    DBTreeSrCells(&scx, 0, cifHierCopyMaskHints,
+    DBTreeSrCells(&scx, 0, CIFCopyMaskHints,
                 (ClientData)CIFComponentDef);
 
     CIFErrorDef = (CellDef *) NULL;

cif/CIFint.h

@@ -145,6 +145,8 @@ typedef struct cifop
  * 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.
+ * CIFOP_NOTSQUARE -	Added 2/26/26---Keep only geometry which is not square.
+ * CIFOP_TAGGED -	Added 3/11/26---Find geometry attached to the given text label
  */
 
 #define CIFOP_AND	1
@@ -172,6 +174,8 @@ typedef struct cifop
 #define CIFOP_BRIDGE	23
 #define CIFOP_BRIDGELIM 24
 #define CIFOP_MASKHINTS 25
+#define CIFOP_NOTSQUARE 26
+#define CIFOP_TAGGED    27
 
 /* Definitions of bit fields used in the value of co_client for CIFOP_INTERACT */
 #define CIFOP_INT_NOT	   0x1		/* Inverted sense (not interacting) */
@@ -336,9 +340,8 @@ extern Plane *CIFGenLayer(CIFOp *op, const Rect *area, CellDef *cellDef, CellDef
                           bool hier, ClientData clientdata);
 extern void CIFInitCells(void);
 extern int cifHierCopyFunc(Tile *tile, TileType dinfo, TreeContext *cxp);
-extern int cifHierCopyMaskHints(SearchContext *scx, ClientData clientData);
 extern void CIFLoadStyle(char *stylename);
-extern void CIFCopyMaskHints(SearchContext *scx, CellDef *targetDef);
+extern int CIFCopyMaskHints(SearchContext *scx, CellDef *targetDef);
 
 /* C99 compat */
 extern void CIFCoverageLayer(CellDef *rootDef, Rect *area, char *layer, bool dolist);

cif/CIFrdcl.c

@@ -613,7 +613,7 @@ CIFPaintCurrent(
 	CIFOp *op;
 
 	plane = CIFGenLayer(cifCurReadStyle->crs_layers[i]->crl_ops,
-	    &TiPlaneRect, (CellDef *)NULL, (CellDef *)NULL,
+	    &TiPlaneRect, cifReadCellDef, cifReadCellDef,
 	    cifCurReadPlanes, FALSE, (ClientData)NULL);
 
 	/* Generate a paint/erase table, then paint from the CIF
@@ -688,6 +688,8 @@ CIFPaintCurrent(
 	    }
 	    else if (op == NULL)
 	    {
+		LinkedRect *lrec = NULL, *lsrch;
+
 		/* Handle boundary layer */
 
 		op = cifCurReadStyle->crs_layers[i]->crl_ops;
@@ -702,6 +704,102 @@ CIFPaintCurrent(
 			(ClientData)NULL) == 1))
 		    DBSrPaintArea((Tile *) NULL, plane, &TiPlaneRect,
 			&CIFSolidBits, cifMakeBoundaryFunc, INT2CD(filetype));
+
+		/* Handle mask-hints input operator */
+
+		op = cifCurReadStyle->crs_layers[i]->crl_ops;
+		while (op)
+		{
+		    if (op->co_opcode == CIFOP_MASKHINTS) break;
+		    op = op->co_next;
+		}
+
+		if (op && (DBSrPaintArea((Tile *)NULL, plane, &TiPlaneRect,
+			&DBAllButSpaceBits, cifCheckPaintFunc,
+			(ClientData)NULL) == 1))
+		{
+		    /* (To do:  remove the linked Rects and paint directly
+		     * into the plane in cifMaskHintFunc())
+		     */
+		    DBSrPaintArea((Tile *) NULL, plane, &TiPlaneRect,
+				&CIFSolidBits, cifMaskHintFunc,
+				(ClientData)&lrec);
+
+		    if (lrec != NULL)
+		    {
+			PropertyRecord *proprec, *proporig;
+			char *propname, *layername;
+			int proplen, i, savescale;
+			bool origfound = FALSE;
+			Plane *plane;
+	
+			layername = (char *)op->co_client;
+		    	propname = (char *)mallocMagic(11 + strlen(layername));
+		    	sprintf(propname, "MASKHINTS_%s", layername);
+	
+			/* If there is already a mask hint plane for this layer,
+			 * then add to it;  otherwise, create a new plane.
+			 */
+			proprec = DBPropGet(cifReadCellDef, layername, &origfound);
+			if (origfound)
+			    plane = proprec->prop_value.prop_plane;
+			else
+			{
+			    proprec = (PropertyRecord *)mallocMagic(
+					sizeof(PropertyRecord));
+			    proprec->prop_type = PROPERTY_TYPE_PLANE;
+			    proprec->prop_len = 0;	/* (unused) */
+			    plane = DBNewPlane((ClientData)TT_SPACE);
+			    proprec->prop_value.prop_plane = plane;
+			    DBPropPut(cifReadCellDef, propname, proprec);
+			}
+
+		    	while (lrec != NULL)
+		    	{
+			    lrec->r_r.r_xtop =
+					CIFScaleCoord(lrec->r_r.r_xtop, COORD_EXACT);
+			    savescale = cifCurReadStyle->crs_scaleFactor;
+			    lrec->r_r.r_ytop =
+					CIFScaleCoord(lrec->r_r.r_ytop, COORD_EXACT);
+			    if (savescale != cifCurReadStyle->crs_scaleFactor)
+			    {
+				lrec->r_r.r_xtop *=
+					(savescale / cifCurReadStyle->crs_scaleFactor);
+				savescale = cifCurReadStyle->crs_scaleFactor;
+			    }
+			    lrec->r_r.r_xbot =
+					CIFScaleCoord(lrec->r_r.r_xbot, COORD_EXACT);
+			    if (savescale != cifCurReadStyle->crs_scaleFactor)
+			    {
+				lrec->r_r.r_xtop *=
+					(savescale / cifCurReadStyle->crs_scaleFactor);
+				lrec->r_r.r_ytop *=
+					(savescale / cifCurReadStyle->crs_scaleFactor);
+				savescale = cifCurReadStyle->crs_scaleFactor;
+			    }
+			    lrec->r_r.r_ybot =
+					CIFScaleCoord(lrec->r_r.r_ybot, COORD_EXACT);
+			    if (savescale != cifCurReadStyle->crs_scaleFactor)
+			    {
+				lrec->r_r.r_xtop *=
+					(savescale / cifCurReadStyle->crs_scaleFactor);
+				lrec->r_r.r_ytop *=
+					(savescale / cifCurReadStyle->crs_scaleFactor);
+				lrec->r_r.r_xbot *=
+					(savescale / cifCurReadStyle->crs_scaleFactor);
+			    }
+
+			    DBPaintPlane(plane, &lrec->r_r, CIFPaintTable,
+					(PaintUndoInfo *)NULL);
+	
+			    free_magic1_t mm1 = freeMagic1_init();
+			    freeMagic1(&mm1, lrec);
+			    lrec = lrec->r_next;
+			    freeMagic1_end(&mm1);
+			}
+		    	freeMagic(propname);
+		    }
+		}
 	    }
 
 	    /* Swap planes */
@@ -790,9 +888,7 @@ CIFPaintCurrent(
 
     	for (i = 0; i < cifNReadLayers; i++)
 	{
-	    LinkedRect *lrec = NULL;
+	    LinkedRect *lrec = NULL, *lsrch;
-	    char *propstr = NULL;
-	    char locstr[512];
 	    Plane *tempp;
 
 	    if (!TTMaskHasType(CalmaMaskHints, i)) continue;
@@ -817,53 +913,55 @@ CIFPaintCurrent(
 			(CellDef *)NULL, CIFPlanes, FALSE, (ClientData)NULL);
 
 	    /* Scan the resulting plane and generate linked Rect structures for
-	     * each shape found.
+	     * each shape found.  (To do:  Remove the linked Rects and paint
+	     * directly into the plane in cifMaskHintFunc(), which is more
+	     * efficient but not hugely so.)
 	     */
 	    DBSrPaintArea((Tile *)NULL, presult, &TiPlaneRect, &CIFSolidBits,
 			cifMaskHintFunc, (ClientData)&lrec);
 
 	    if (lrec != NULL)
 	    {
+		PropertyRecord *proprec;
+		bool propfound;
 		char *propname;
+		Plane *plane;
 
 	    	propname = (char *)mallocMagic(11 + strlen(cifReadLayers[i]));
 	    	sprintf(propname, "MASKHINTS_%s", cifReadLayers[i]);
 
-	    	propstr = (char *)NULL;
+	    	/* Paint all linked Rects into a mask-hints property plane
-
+		 * in the target cell.
-	    	/* Turn all linked Rects into a mask-hints property in the
-		 * target cell.
 		 */
+
+		proprec = DBPropGet(cifReadCellDef, propname, &propfound);
+		if (!propfound)
+		{
+		    proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+		    proprec->prop_type = PROPERTY_TYPE_PLANE;
+		    proprec->prop_len = 0;	/* (unused) */
+		    plane = DBNewPlane((ClientData)TT_SPACE);
+		    proprec->prop_value.prop_plane = plane;
+		    DBPropPut(cifReadCellDef, propname, proprec);
+		}
+		else
+		    plane = proprec->prop_value.prop_plane;
+
 	    	while (lrec != NULL)
 	    	{
-		    char *newstr;
+		    lrec->r_r.r_xbot /= CIFCurStyle->cs_scaleFactor;
-		    sprintf(locstr, "%d %d %d %d",
+		    lrec->r_r.r_ybot /= CIFCurStyle->cs_scaleFactor;
-				lrec->r_r.r_xbot / CIFCurStyle->cs_scaleFactor,
+		    lrec->r_r.r_xtop /= CIFCurStyle->cs_scaleFactor;
-				lrec->r_r.r_ybot / CIFCurStyle->cs_scaleFactor,
+		    lrec->r_r.r_ytop /= CIFCurStyle->cs_scaleFactor;
-				lrec->r_r.r_xtop / CIFCurStyle->cs_scaleFactor,
+
-				lrec->r_r.r_ytop / CIFCurStyle->cs_scaleFactor);
+		    DBPaintPlane(plane, &lrec->r_r, CIFPaintTable,
-		    if (propstr == NULL)
+				(PaintUndoInfo *)NULL);
-		    {
+
-		    	newstr = (char *)mallocMagic(strlen(locstr) + 1);
-		    	sprintf(newstr, "%s", locstr);
-		    }
-		    else
-		    {
-		    	newstr = (char *)mallocMagic(strlen(locstr)
-					+ strlen(propstr) + 2);
-		    	sprintf(newstr, "%s %s", propstr, locstr);
-		    	freeMagic(propstr);
-		    }
-		    propstr = newstr;
 		    free_magic1_t mm1 = freeMagic1_init();
 		    freeMagic1(&mm1, lrec);
 		    lrec = lrec->r_next;
 		    freeMagic1_end(&mm1);
 		}
-		/* NOTE: propstr is transferred to the CellDef and should
-		 * not be free'd here.
-		 */
-		DBPropPut(cifReadCellDef, propname, propstr);
 	    	freeMagic(propname);
 	    }
 
@@ -902,6 +1000,7 @@ cifMakeBoundaryFunc(
     /* If there are multiple rectangles defined with the boundary   */
     /* layer, then the last one defines the FIXED_BBOX property.    */
 
+    PropertyRecord *proprec;
     Rect area;
     char propertyvalue[128], *storedvalue;
     int savescale;
@@ -933,19 +1032,24 @@ cifMakeBoundaryFunc(
 
     if (cifReadCellDef->cd_flags & CDFIXEDBBOX)
     {
-	char *propvalue;
+	PropertyRecord *proprec;
 	bool found;
 
 	/* Only flag a warning if the redefined boundary was	*/
 	/* different from the original.				*/
 
-	propvalue = (char *)DBPropGet(cifReadCellDef, "FIXED_BBOX", &found);
+	proprec = DBPropGet(cifReadCellDef, "FIXED_BBOX", &found);
 	if (found)
 	{
 	    Rect bbox;
-	    if (sscanf(propvalue, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
+	    if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
-		    &bbox.r_xtop, &bbox.r_ytop) == 4)
+			(proprec->prop_len == 4))
 	    {
+		bbox.r_xbot = proprec->prop_value.prop_integer[0];
+		bbox.r_ybot = proprec->prop_value.prop_integer[1];
+		bbox.r_xtop = proprec->prop_value.prop_integer[2];
+		bbox.r_ytop = proprec->prop_value.prop_integer[3];
+
 		if ((bbox.r_xbot != area.r_xbot) ||
 			(bbox.r_ybot != area.r_ybot) ||
 			(bbox.r_xtop != area.r_xtop) ||
@@ -962,10 +1066,15 @@ cifMakeBoundaryFunc(
 	}
     }
 
-    sprintf(propertyvalue, "%d %d %d %d",
+    proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) + 2 * sizeof(int));
-	    area.r_xbot, area.r_ybot, area.r_xtop, area.r_ytop);
+    proprec->prop_type = PROPERTY_TYPE_DIMENSION;
-    storedvalue = StrDup((char **)NULL, propertyvalue);
+    proprec->prop_len = 4;
-    DBPropPut(cifReadCellDef, "FIXED_BBOX", storedvalue);
+    proprec->prop_value.prop_integer[0] = area.r_xbot;
+    proprec->prop_value.prop_integer[1] = area.r_ybot;
+    proprec->prop_value.prop_integer[2] = area.r_xtop;
+    proprec->prop_value.prop_integer[3] = area.r_ytop;
+
+    DBPropPut(cifReadCellDef, "FIXED_BBOX", proprec);
     cifReadCellDef->cd_flags |= CDFIXEDBBOX;
     return 0;
 }
@@ -1677,8 +1786,8 @@ CIFReadCellCleanup(
     }
 
     /* Do geometrical processing on the top-level cell. */
+    if (filetype == FILE_CIF) CIFPaintCurrent(filetype);
 
-    CIFPaintCurrent(FILE_CIF);
     DBAdjustLabels(EditCellUse->cu_def, &TiPlaneRect);
     DBReComputeBbox(EditCellUse->cu_def);
     DBWAreaChanged(EditCellUse->cu_def, &EditCellUse->cu_def->cd_bbox,

cif/CIFrdpt.c

@@ -244,40 +244,61 @@ CIFPropRecordPath(
 {
     extern float CIFGetOutputScale(int convert);
     CIFPath *pathp;
-    char *pathstr, *sptr;
+    char *namestr = NULL;
-    int components;
+    int components, i, x, y, mult, pathnum;
-    float x, y, oscale, mult;
+    PropertyRecord *proprec;
+    bool propfound;
 
-    oscale = CIFGetOutputScale(1000);   /* 1000 for conversion to um */
+    /* If "name" is a property, then append a suffix to it to ensure uniqueness */
-    if (oscale == 0.0) oscale = 1.0;
+    DBPropGet(def, propname, &propfound);
-    mult = (iswire == TRUE) ? 0.5 : 1.0;
+    if (propfound)
+    {
+	pathnum = 0;
+	namestr = mallocMagic(strlen(propname) + 10);
+	while (propfound)
+	{
+	    sprintf(namestr, "%s_%d", propname, pathnum);
+	    DBPropGet(def, namestr, &propfound);
+	    pathnum++;
+	}
+    }
 
-    pathp = pathheadp;
+    mult = (iswire == TRUE) ? 1 : 0;
-    components = 0;
 
     /* Count the number of components in the path */
+    pathp = pathheadp;
+    components = 0;
     while (pathp != NULL)
     {
-	pathp = pathp->cifp_next;
 	components++;
+	pathp = pathp->cifp_next;
     }
-    /* Allocate enough space to hold 2 * N points at "infinity" */
+    /* Allocate enough space to hold 2 * N points. */
-    pathstr = (char *)mallocMagic(components * 40);
+    proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
+		((components - 1) * 2) * sizeof(int));
+    proprec->prop_type = PROPERTY_TYPE_DIMENSION;
+    proprec->prop_len = components * 2;
 
     pathp = pathheadp;
-    sptr = pathstr;
+    i = 0;
     while (pathp != NULL)
     {
-	x = (float)pathp->cifp_x * oscale * mult;
+	x = pathp->cifp_x >> mult;
-	y = (float)pathp->cifp_y * oscale * mult;
+	y = pathp->cifp_y >> mult;
-	sprintf(sptr, "%.3f %.3f ", x, y);
+        
-	sptr = sptr + strlen(sptr);
+	proprec->prop_value.prop_integer[i] = x;
+	proprec->prop_value.prop_integer[i + 1] = y;
+
+	i += 2;
 	pathp = pathp->cifp_next;
     }
-
+    if (namestr)
-    /* Reallocate pathstr to be no larger than needed to hold the path contents */
+    {
-    StrDup(&pathstr, pathstr);
+	DBPropPut(def, namestr, proprec);
-    DBPropPut(def, propname, (ClientData)pathstr);
+	freeMagic(namestr);
+    }
+    else
+	DBPropPut(def, propname, proprec);
 }
 
 /*

cif/CIFrdtech.c

@@ -324,14 +324,19 @@ cifNewReadStyle(void)
     {
 	/* Destroy old style and free all memory allocated to it */
 
-	for (i=0; i<MAXCIFRLAYERS; i+=1)
+	for (i = 0; i < MAXCIFRLAYERS; i++)
 	{
 	    layer = cifCurReadStyle->crs_layers[i];
 	    if (layer != NULL)
 	    {
 		free_magic1_t mm1 = freeMagic1_init();
 		for (op = layer->crl_ops; op != NULL; op = op->co_next)
+		{
+		    if (op->co_opcode == CIFOP_MASKHINTS ||
+				op->co_opcode == CIFOP_TAGGED)
+			freeMagic((char *)op->co_client);
 		    freeMagic1(&mm1, (char *)op);
+		}
 		freeMagic1_end(&mm1);
 		freeMagic((char *)layer);
 	    }
@@ -990,6 +995,12 @@ CIFReadTechLine(
 	newOp->co_opcode = CIFOP_COPYUP;
     else if (strcmp(argv[0], "boundary") == 0)
 	newOp->co_opcode = CIFOP_BOUNDARY;
+    else if (strcmp(argv[0], "not-square") == 0)
+	newOp->co_opcode = CIFOP_NOTSQUARE;
+    else if (strcmp(argv[0], "mask-hints") == 0)
+	newOp->co_opcode = CIFOP_MASKHINTS;
+    else if (strcmp(argv[0], "tagged") == 0)
+	newOp->co_opcode = CIFOP_TAGGED;
     else
     {
 	TechError("Unknown statement \"%s\".\n", argv[0]);
@@ -1016,6 +1027,15 @@ CIFReadTechLine(
 		goto errorReturn;
 	    }
 	    break;
+        case CIFOP_MASKHINTS:
+            if (argc != 2) goto wrongNumArgs;
+            newOp->co_client = (ClientData)StrDup((char **)NULL, argv[1]);
+            break;
+        case CIFOP_TAGGED:
+            if (argc != 3) goto wrongNumArgs;
+            newOp->co_client = (ClientData)StrDup((char **)NULL, argv[1]);
+	    CIFParseReadLayers(argv[2], &newOp->co_cifMask, TRUE);
+            break;
     }
 
     /* Link the new CIFOp onto the list. */
@@ -1099,6 +1119,7 @@ CIFReadTechFinal(void)
  *
  * ----------------------------------------------------------------------------
  */
+
 void
 CIFReadLoadStyle(
     char *stylename)

cif/CIFsee.c

@@ -166,9 +166,9 @@ CIFPaintLayer(
     scx.scx_use = CIFDummyUse;
     scx.scx_trans = GeoIdentityTransform;
     (void) DBTreeSrTiles(&scx, &DBAllButSpaceAndDRCBits, 0,
-	cifHierCopyFunc, (ClientData) CIFComponentDef);
+		cifHierCopyFunc, (ClientData) CIFComponentDef);
     CIFCopyMaskHints(&scx, CIFComponentDef);
-    DBTreeSrCells(&scx, 0, cifHierCopyMaskHints,
+    DBTreeSrCells(&scx, 0, CIFCopyMaskHints,
                 (ClientData)CIFComponentDef);
 
     oldCount = DBWFeedbackCount;
@@ -287,9 +287,9 @@ CIFSeeLayer(
     scx.scx_use = CIFDummyUse;
     scx.scx_trans = GeoIdentityTransform;
     (void) DBTreeSrTiles(&scx, &DBAllButSpaceAndDRCBits, 0,
-	cifHierCopyFunc, (ClientData) CIFComponentDef);
+		cifHierCopyFunc, (ClientData) CIFComponentDef);
     CIFCopyMaskHints(&scx, CIFComponentDef);
-    DBTreeSrCells(&scx, 0, cifHierCopyMaskHints,
+    DBTreeSrCells(&scx, 0, CIFCopyMaskHints,
                 (ClientData)CIFComponentDef);
 
     oldCount = DBWFeedbackCount;
@@ -459,9 +459,9 @@ CIFCoverageLayer(
     scx.scx_use = CIFDummyUse;
     scx.scx_trans = GeoIdentityTransform;
     (void) DBTreeSrTiles(&scx, &DBAllButSpaceAndDRCBits, 0,
-	cifHierCopyFunc, (ClientData) CIFComponentDef);
+		cifHierCopyFunc, (ClientData) CIFComponentDef);
     CIFCopyMaskHints(&scx, CIFComponentDef);
-    DBTreeSrCells(&scx, 0, cifHierCopyMaskHints,
+    DBTreeSrCells(&scx, 0, CIFCopyMaskHints,
                 (ClientData)CIFComponentDef);
 
     CIFGen(CIFComponentDef, rootDef, area, CIFPlanes, &depend, TRUE, TRUE,
@@ -504,10 +504,10 @@ CIFCoverageLayer(
     }
     else
     {
-    	TxPrintf("%s Area = %lld CIF units^2\n", doBox ?  "Cursor Box" :
+    	TxPrintf("%s Area = %"DLONG_PREFIX"d CIF units^2\n", doBox ?  "Cursor Box" :
 		"Cell", btotal);
-    	TxPrintf("Layer Bounding Area = %lld CIF units^2\n", atotal);
+    	TxPrintf("Layer Bounding Area = %"DLONG_PREFIX"d CIF units^2\n", atotal);
-    	TxPrintf("Layer Total Area = %lld CIF units^2\n", cstats.coverage);
+    	TxPrintf("Layer Total Area = %"DLONG_PREFIX"d CIF units^2\n", cstats.coverage);
     	TxPrintf("Coverage in %s = %1.1f%%\n", doBox ? "box" :
 		"cell", 100.0 * fcover);
     }

cif/CIFtech.c

@@ -1107,6 +1107,8 @@ CIFTechLine(
 	newOp->co_opcode = CIFOP_BBOX;
     else if (strcmp(argv[0], "net") == 0)
 	newOp->co_opcode = CIFOP_NET;
+    else if (strcmp(argv[0], "tagged") == 0)
+	newOp->co_opcode = CIFOP_TAGGED;
     else if (strcmp(argv[0], "maxrect") == 0)
 	newOp->co_opcode = CIFOP_MAXRECT;
     else if (strcmp(argv[0], "boundary") == 0)
@@ -1117,6 +1119,8 @@ CIFTechLine(
 	newOp->co_opcode = CIFOP_CLOSE;
     else if (strcmp(argv[0], "orthogonal") == 0)
 	newOp->co_opcode = CIFOP_MANHATTAN;
+    else if (strcmp(argv[0], "not-square") == 0)
+	newOp->co_opcode = CIFOP_NOTSQUARE;
     else if (strcmp(argv[0], "bridge") == 0)
 	newOp->co_opcode = CIFOP_BRIDGE;
     else if (strcmp(argv[0], "bridge-lim") == 0)
@@ -1355,6 +1359,7 @@ bloatCheck:
 	    bloatDone: break;
 
 	case CIFOP_NET:
+	case CIFOP_TAGGED:
 	    if (argc != 3) goto wrongNumArgs;
 	    newOp->co_client = (ClientData)StrDup((char **)NULL, argv[1]);
 	    cifParseLayers(argv[2], CIFCurStyle, &newOp->co_paintMask,
@@ -1669,12 +1674,12 @@ cifComputeRadii(
 
     for (op = layer->cl_ops; op != NULL; op = op->co_next)
     {
-	/* BBOX, NET, and MASKHINTS operators should never be used	*/
+	/* BBOX, NET, TAGGED, and MASKHINTS operators should never be	*/
-	/* hierarchically so ignore any grow/shrink operators that	*/
+	/* used	hierarchically so ignore any grow/shrink operators that	*/
 	/* come after them.						*/
 
 	if (op->co_opcode == CIFOP_BBOX || op->co_opcode == CIFOP_NET ||
-		    op->co_opcode == CIFOP_MASKHINTS)
+		    op->co_opcode == CIFOP_TAGGED || op->co_opcode == CIFOP_MASKHINTS)
 	    break;
 
 	/* If CIF layers are used, switch to the max of current
@@ -1986,8 +1991,8 @@ CIFTechFinal(void)
 		/* Presence of op->co_opcode in CIFOP_OR indicates a copy */
 		/* of the SquaresData pointer from a following operator.  */
 		/* CIFOP_BBOX and CIFOP_MAXRECT uses the co_client field  */
-		/* as a flag field, while CIFOP_NET and CIFOP_MASKHINTS	  */
+		/* as a flag field, while CIFOP_NET, CIFOP_MASKHINTS, and */
-		/* uses it for a string.				  */
+		/* CIFOP_TAGGED use it for a string.			  */
 		else
 		{
 		    switch (op->co_opcode)
@@ -1999,6 +2004,7 @@ CIFTechFinal(void)
 			case CIFOP_MAXRECT:
 			case CIFOP_MANHATTAN:
 			case CIFOP_NET:
+			case CIFOP_TAGGED:
 			    break;
 			case CIFOP_BRIDGELIM:
 			case CIFOP_BRIDGE:
@@ -2534,6 +2540,7 @@ CIFTechOutputScale(
 			case CIFOP_MAXRECT:
 			case CIFOP_MANHATTAN:
 			case CIFOP_NET:
+			case CIFOP_TAGGED:
 			case CIFOP_INTERACT:
 			    break;
 			case CIFOP_BRIDGELIM:
@@ -2649,8 +2656,8 @@ CIFTechOutputScale(
 		    default:
 			/* op->co_opcode in CIFOP_OR is a pointer copy,	*/
 			/* in CIFOP_BBOX and CIFOP_MAXRECT is a	flag,	*/
-			/* and in CIFOP_NET and CIFOP_MASKHINTS is a	*/
+			/* and in CIFOP_NET, CIFOP_MASKHINTS, and	*/
-			/* string.					*/
+			/* CIFOP_TAGGED is a string.			*/
 			break;
 		}
 	    }

commands/CmdAB.c

@@ -779,8 +779,8 @@ CmdBox(
 	    break;
 	case BOX_EXISTS:
 #ifdef MAGIC_WRAPPER
-	    Tcl_SetResult(magicinterp, ToolGetBox(NULL, NULL) ?  "1" : "0",
+	    Tcl_SetObjResult(magicinterp,
-			NULL);
+			Tcl_NewBooleanObj(ToolGetBox(NULL, NULL) ?  TRUE : FALSE));
 #else
 	    TxPrintf("%s\n", ToolGetBox(NULL, NULL) ? "True" : "False");
 #endif

commands/CmdCD.c

@@ -117,12 +117,13 @@ bool cmdDumpParseArgs(char *cmdName, MagWindow *w, TxCommand *cmd, CellUse *dumm
 #define CALMA_READ	19
 #define CALMA_READONLY	20
 #define CALMA_RESCALE	21
-#define CALMA_WARNING	22
+#define CALMA_SAVEPATHS	22
-#define CALMA_WRITE	23
+#define CALMA_WARNING	23
-#define CALMA_POLYS	24
+#define CALMA_WRITE	24
-#define CALMA_PATHS	25
+#define CALMA_POLYS	25
-#define CALMA_UNDEFINED	26
+#define CALMA_PATHS	26
-#define CALMA_UNIQUE	27
+#define CALMA_UNDEFINED	27
+#define CALMA_UNIQUE	28
 
 #define CALMA_WARN_HELP CIF_WARN_END	/* undefined by CIF module */
 
@@ -175,6 +176,7 @@ CmdCalma(
 	"		into edit cell",
 	"readonly [yes|no]	set cell as read-only and generate output from GDS file",
 	"rescale [yes|no]	allow or disallow internal grid subdivision",
+	"savepaths [yes|no]	save path centerlines as cell properties",
 	"warning [option]	set warning information level",
 	"write file		output Calma GDS-II format to \"file\"\n"
 	"		for the window's root cell",
@@ -738,6 +740,27 @@ CmdCalma(
 		CalmaSubcellPolygons = (unsigned char)option;
 	    return;
 
+	case CALMA_SAVEPATHS:
+	    if (cmd->tx_argc == 2)
+	    {
+#ifdef MAGIC_WRAPPER
+		Tcl_SetObjResult(magicinterp, Tcl_NewBooleanObj(CalmaRecordPaths));
+#else
+		TxPrintf("Paths in GDS cells read from input file are%s recorded"
+				" as cell properties.\n",
+			(CalmaRecordPaths) ?  " " : " not");
+#endif
+		return;
+	    }
+	    else if (cmd->tx_argc != 3)
+		goto wrongNumArgs;
+
+	    option = Lookup(cmd->tx_argv[2], cmdCalmaYesNo);
+	    if (option < 0)
+		goto wrongNumArgs;
+	    CalmaRecordPaths = (option < 4) ? FALSE : TRUE;
+	    return;
+
 	case CALMA_NO_DUP:
 	    if (cmd->tx_argc == 2)
 	    {
@@ -1300,7 +1323,7 @@ CmdCellname(
 	    if (cellDef == (CellDef *) NULL)
 		TxError("Unknown cell %s\n", cellname);
 	    else
-		CmdDoProperty(cellDef, cmd, 3 + ((dolist) ? 1 : 0));
+		CmdDoProperty(cellDef, w, cmd, 3 + ((dolist) ? 1 : 0));
 	    break;
 
 	case IDX_DELETE:
@@ -4991,15 +5014,20 @@ cmdDumpParseArgs(
     bbox = def->cd_bbox;
     if (def->cd_flags & CDFIXEDBBOX)
     {
-	char *propvalue;
+	PropertyRecord *proprec;
 	bool found;
 
-	propvalue = (char *)DBPropGet(def, "FIXED_BBOX", &found);
+	proprec = DBPropGet(def, "FIXED_BBOX", &found);
 	if (found)
 	{
-	    if (sscanf(propvalue, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
+	    if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
-		    &bbox.r_xtop, &bbox.r_ytop) != 4)
+			(proprec->prop_len == 4))
-		bbox = def->cd_bbox;
+	    {
+		bbox.r_xbot = proprec->prop_value.prop_integer[0];
+		bbox.r_ybot = proprec->prop_value.prop_integer[1];
+		bbox.r_xtop = proprec->prop_value.prop_integer[2];
+		bbox.r_ytop = proprec->prop_value.prop_integer[3];
+	    }
 	}
     }
 

commands/CmdE.c

@@ -781,39 +781,82 @@ cmdEraseCellsFunc(
  * Implement the "expand" command.
  *
  * Usage:
- *	expand
+ *	expand [selection|surround|overlap|all] [toggle]
- *	expand toggle
+ *
+ *	"selection" expands cells in the selection.  All other options
+ *	expand cells in the layout.  "all" expands all cells in the
+ *	layout.  "surround" expands cells which the cursor box
+ *	surrounds completely, and "overlap" expands cells which the
+ *	cursor box overlaps.
+ *
+ *	If "toggle" is specified, flips the expanded/unexpanded status.
+ *	Cells which were expanded are unexpanded, and cells which were
+ *	unexpanded are expanded.
+ *
+ *	For backwards compatibility:
+ *	"expand" alone implements "expand overlap".
+ *	"expand toggle" implements "expand selection toggle".
+ *
+ *	Also see:  CmdUnexpand
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	If "toggle" is specified, flips the expanded/unexpanded status
+ *	Expansion state of cells is changed.  May read cells in from
- *	of all selected cells.  Otherwise, aren't any unexpanded cells
+ *	disk, and update bounding boxes that have changed.
- *	left under the box.  May read cells in from disk, and updates
- *	bounding boxes that have changed.
  *
  * ----------------------------------------------------------------------------
  */
 
+#define EXPAND_SELECTION      0
+#define EXPAND_SURROUND       1
+#define EXPAND_OVERLAP        2
+#define EXPAND_ALL            3
+#define EXPAND_HELP           4
+
 void
 CmdExpand(
     MagWindow *w,
     TxCommand *cmd)
 {
-    int windowMask, boxMask, d;
+    int windowMask, boxMask, d, option;
+    bool doToggle = FALSE;
+    const char * const *msg;
     Rect rootRect;
     CellUse *rootBoxUse;
     CellDef *rootBoxDef;
+
     int cmdExpandFunc(CellUse *use, int windowMask);		/* Forward reference. */
 
-    if (cmd->tx_argc > 2 || (cmd->tx_argc == 2
+    static const char * const cmdExpandOption[] = {
-	&& (strncmp(cmd->tx_argv[1], "toggle", strlen(cmd->tx_argv[1])) != 0)))
+	"selection	expand cell instances in the selection",
+	"surround	expand cell instances which the cursor box surrounds",
+	"overlap	expand cell instances which the cursor box overlaps",
+	"all		expand all cell instances",
+	NULL
+    };
+
+    if (cmd->tx_argc > 1)
     {
-	TxError("Usage: %s or %s toggle\n", cmd->tx_argv[0], cmd->tx_argv[0]);
+	if (!strncmp(cmd->tx_argv[cmd->tx_argc - 1], "toggle",
-	return;
+			strlen(cmd->tx_argv[cmd->tx_argc - 1])))
+	{
+	    doToggle = TRUE;
+	    cmd->tx_argc--;
+	}
     }
 
+    if (cmd->tx_argc > 1)
+    {
+	option = Lookup(cmd->tx_argv[1], cmdExpandOption);
+	if (option < 0) option = EXPAND_HELP;
+    }
+    else
+	option = EXPAND_OVERLAP;
+
+    if (option == EXPAND_HELP) goto badusage;
+
     windCheckOnlyWindow(&w, DBWclientID);
     if (w == (MagWindow *) NULL)
     {
@@ -844,23 +887,95 @@ CmdExpand(
             WindScale(d, 1);
 	    TxPrintf("expand: rescaled by %d\n", d);
 	    d = DBLambda[1];
-	    if (cmd->tx_argc == 2) break;	/* Don't toggle twice */
+	    if (doToggle) break;	/* Don't toggle twice */
 	}
 	(void) ToolGetBoxWindow(&rootRect, &boxMask);
 
-	if (cmd->tx_argc == 2)
+	if (option != EXPAND_SELECTION)
-	    SelectExpand(windowMask);
-	else
 	{
 	    if ((boxMask & windowMask) != windowMask)
 	    {
 		TxError("The box isn't in the same window as the cursor.\n");
 		return;
 	    }
-	    DBExpandAll(rootBoxUse, &rootRect, windowMask,
+	}
-			TRUE, cmdExpandFunc, (ClientData)(pointertype) windowMask);
+
+	switch (option)
+	{
+	    case EXPAND_SELECTION:
+		SelectExpand(windowMask,
+			(doToggle) ? DB_EXPAND_TOGGLE : DB_EXPAND,
+			(Rect *)NULL, FALSE);
+		break;
+	    case EXPAND_OVERLAP:
+		if (doToggle)
+		{
+		    DBExpandAll(rootBoxUse, &rootRect, windowMask,
+				DB_EXPAND_TOGGLE | DB_EXPAND_OVERLAP,
+				cmdExpandFunc, (ClientData)(pointertype)windowMask);
+		    SelectExpand(windowMask, 
+				DB_EXPAND_TOGGLE | DB_EXPAND_OVERLAP,
+				&rootRect, FALSE);
+		}
+		else
+		{
+		    DBExpandAll(rootBoxUse, &rootRect, windowMask,
+				DB_EXPAND | DB_EXPAND_OVERLAP,
+				cmdExpandFunc, (ClientData)(pointertype)windowMask);
+		    SelectExpand(windowMask, 
+				DB_EXPAND | DB_EXPAND_OVERLAP,
+				&rootRect, FALSE);
+		}
+		break;
+	    case EXPAND_SURROUND:
+		if (doToggle)
+		{
+		    DBExpandAll(rootBoxUse, &rootRect, windowMask,
+				DB_EXPAND_TOGGLE | DB_EXPAND_SURROUND,
+				cmdExpandFunc, (ClientData)(pointertype)windowMask);
+		    SelectExpand(windowMask, 
+				DB_EXPAND_TOGGLE | DB_EXPAND_SURROUND,
+				&rootRect, TRUE);
+		}
+		else
+		{
+		    DBExpandAll(rootBoxUse, &rootRect, windowMask,
+				DB_EXPAND | DB_EXPAND_SURROUND,
+				cmdExpandFunc, (ClientData)(pointertype)windowMask);
+		    SelectExpand(windowMask, 
+				DB_EXPAND | DB_EXPAND_SURROUND,
+				&rootRect, TRUE);
+		}
+		break;
+	    case EXPAND_ALL:
+		if (doToggle)
+		{
+		    DBExpandAll(rootBoxUse, &TiPlaneRect, windowMask,
+				DB_EXPAND | DB_EXPAND_OVERLAP,
+				cmdExpandFunc, (ClientData)(pointertype)windowMask);
+		    SelectExpand(windowMask, 
+				DB_EXPAND | DB_EXPAND_OVERLAP,
+				(Rect *)NULL, FALSE);
+		}
+		else
+		{
+		    DBExpandAll(rootBoxUse, &TiPlaneRect, windowMask,
+				DB_EXPAND | DB_EXPAND_OVERLAP,
+				cmdExpandFunc, (ClientData)(pointertype)windowMask);
+		    SelectExpand(windowMask, 
+				DB_EXPAND | DB_EXPAND_OVERLAP,
+				(Rect *)NULL, FALSE);
+		}
+		break;
 	}
     } while (d != DBLambda[1]);
+
+    return;
+
+badusage:
+    for (msg = &(cmdExpandOption[0]); *msg != NULL; msg++)
+	TxPrintf("    %s\n", *msg);
+    TxPrintf("    toggle	Toggle the visibility of cell instances.\n");
 }
 
 /* This function is called for each cell whose expansion status changed.

commands/CmdLQ.c

@@ -45,9 +45,8 @@ static const char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magi
 #include "utils/undo.h"
 #include "select/select.h"
 #include "netmenu/netmenu.h"
-
-/* C99 compat */
 #include "cif/cif.h"
+#include "cif/CIFint.h"
 
 /* Forward declarations */
 
@@ -518,14 +517,14 @@ CmdLoad(
 
 	    DBExpandAll(topuse, &(topuse->cu_bbox),
 			((DBWclientRec *)w->w_clientData)->dbw_bitmask,
-			TRUE, keepGoing, NULL);
+			DB_EXPAND, keepGoing, NULL);
 
 	    DBExpandAll(topuse, &(topuse->cu_bbox),
 			((DBWclientRec *)w->w_clientData)->dbw_bitmask,
-			FALSE, keepGoing, NULL);
+			DB_UNEXPAND, keepGoing, NULL);
 	    DBExpand(topuse,
 			((DBWclientRec *)w->w_clientData)->dbw_bitmask,
-			TRUE);
+			DB_EXPAND);
 
 	    /* We don't want to save and restore DBLambda, because      */
 	    /* loading the file may change their values.  Instead, we   */
@@ -2296,6 +2295,8 @@ parsepositions:
     editDef->cd_flags |= (CDMODIFIED | CDGETNEWSTAMP);
 }
 
+#define PROPERTY_TYPE_COMPAT	4	/* Last entry in cmdPropertyType */
+
 /*
  * ----------------------------------------------------------------------------
  *
@@ -2319,47 +2320,448 @@ parsepositions:
 void
 CmdDoProperty(
     CellDef *def,
+    MagWindow *w,
     TxCommand *cmd,
     int argstart)
 {
-    int printPropertiesFunc();
+    PropertyRecord *proprec;
     char *value;
-    bool propfound;
+    bool propfound, dolist;
+    int proptype, proplen, propvalue, i;
+    dlong dvalue;
     int locargc = cmd->tx_argc - argstart + 1;
+#ifdef MAGIC_WRAPPER
+    Tcl_Obj *tobj;
+#endif
+
+    /* Forward declarations */
+    int printPropertiesFunc();
+    int printPlanePropFunc();		
+
+    /* These should match the property codes in database.h.in, except
+     * for "compat" which must come at the end.
+     */
+    static const char * const cmdPropertyType[] = {
+	"string", "integer", "dimension", "double", "plane", "compat", NULL
+    };
+
+    /* If the first keyword is "list", then set dolist and increment
+     * the starting argument position.
+     */
+    dolist = FALSE;
+    if (locargc > 1)
+    {
+	if (!strcmp(cmd->tx_argv[argstart], "list"))
+	{
+	    dolist = TRUE;
+	    locargc--;
+	    argstart++;
+	}
+    }
+
+    /* If a property type is given, parse it and then strip it from
+     * the arguments list.
+     */
+    if (locargc > 1)
+    {
+	proptype = Lookup(cmd->tx_argv[argstart], cmdPropertyType);
+	if (proptype >= 0)
+	{
+	    if (proptype != PROPERTY_TYPE_COMPAT)
+	    {
+		locargc--;
+		argstart++;
+	    }
+	}
+	else
+	    proptype = PROPERTY_TYPE_STRING;	/* default */
+    }
+    else
+	proptype = PROPERTY_TYPE_STRING;	/* default */
 
     if (locargc == 1)
     {
+#ifdef MAGIC_WRAPPER
+	Tcl_Obj *tobj;
+	/* Create an empty list for the interpreter result; the
+	 * printPropertiesFunc() function will append values to it.
+	 */
+	tobj = Tcl_NewListObj(0, NULL);
+	Tcl_SetObjResult(magicinterp, tobj);
+#endif
 	/* print all properties and their values */
-	DBPropEnum(def, printPropertiesFunc, NULL);
+	DBPropEnum(def, printPropertiesFunc, (ClientData)w);
     }
 
     else if (locargc == 2)
     {
-	/* print the value of the indicated property */
+	/* If the property type was "compat", then give the state of the
-	value = (char *)DBPropGet(def, cmd->tx_argv[argstart], &propfound);
+	 * compatibility flag and return.
-	if (propfound)
+	 */
+	if (proptype == PROPERTY_TYPE_COMPAT)
+	{
 #ifdef MAGIC_WRAPPER
-	    Tcl_SetResult(magicinterp, value, NULL);
+	    Tcl_SetObjResult(magicinterp, Tcl_NewBooleanObj(DBPropCompat));
 #else
-	    TxPrintf("%s", value);
+	    TxPrintf("%s\n", (DBPropCompat == TRUE) ? "True" : "False");
 #endif
+	    return;
+	}
+
+	/* Print the value of the indicated property */
+	proprec = (PropertyRecord *)DBPropGet(def, cmd->tx_argv[argstart], &propfound);
+	if (propfound)
+	{
+	    proptype = proprec->prop_type;
+#ifdef MAGIC_WRAPPER
+	    switch (proptype)
+	    {
+		case PROPERTY_TYPE_STRING:
+		    Tcl_SetResult(magicinterp, proprec->prop_value.prop_string, NULL);
+		    break;
+		case PROPERTY_TYPE_INTEGER:
+		    if (proprec->prop_len == 1)
+			Tcl_SetObjResult(magicinterp,
+				Tcl_NewIntObj(proprec->prop_value.prop_integer[0]));
+		    else
+		    {
+			tobj = Tcl_NewListObj(0, NULL);
+			for (i = 0; i < proprec->prop_len; i++)
+			    Tcl_ListObjAppendElement(magicinterp, tobj,
+					Tcl_NewIntObj(
+					proprec->prop_value.prop_integer[i]));
+			Tcl_SetObjResult(magicinterp, tobj);
+		    }
+		    break;
+		case PROPERTY_TYPE_DIMENSION:
+		    if (proprec->prop_len == 1)
+			Tcl_SetResult(magicinterp,
+				DBWPrintValue(proprec->prop_value.prop_integer[0],
+				w, TRUE), NULL);
+		    else
+		    {
+			tobj = Tcl_NewListObj(0, NULL);
+			for (i = 0; i < proprec->prop_len; i++)
+			    Tcl_ListObjAppendElement(magicinterp, tobj,
+					Tcl_NewStringObj(DBWPrintValue(
+					proprec->prop_value.prop_integer[i], w,
+					((i % 2) == 0) ? TRUE : FALSE), -1));
+			Tcl_SetObjResult(magicinterp, tobj);
+		    }
+		    break;
+		case PROPERTY_TYPE_PLANE:
+		    tobj = Tcl_NewListObj(0, NULL);
+		    DBSrPaintArea(PlaneGetHint(proprec->prop_value.prop_plane),
+				proprec->prop_value.prop_plane,
+				&TiPlaneRect, &CIFSolidBits, printPlanePropFunc,
+				(ClientData)tobj);
+		    Tcl_SetObjResult(magicinterp, tobj);
+		    break;
+		case PROPERTY_TYPE_DOUBLE:
+		    if (proprec->prop_len == 1)
+			Tcl_SetObjResult(magicinterp,
+				Tcl_NewWideIntObj((Tcl_WideInt)
+				proprec->prop_value.prop_double[0]));
+		    else
+		    {
+			tobj = Tcl_NewListObj(0, NULL);
+			for (i = 0; i < proprec->prop_len; i++)
+			    Tcl_ListObjAppendElement(magicinterp, tobj,
+					Tcl_NewWideIntObj((Tcl_WideInt)
+					proprec->prop_value.prop_double[i]));
+			Tcl_SetObjResult(magicinterp, tobj);
+		    }
+		    break;
+	    }
+#else
+	    switch (proptype)
+	    {
+		case PROPERTY_TYPE_STRING:
+		    TxPrintf("%s\n", proprec->prop_value.prop_string);
+		    break;
+		case PROPERTY_TYPE_INTEGER:
+		    for (i = 0; i < proprec->prop_len; i++)
+			TxPrintf("%d ", proprec->prop_value.prop_integer[i]);
+		    TxPrintf("\n");
+		    break;
+		case PROPERTY_TYPE_DIMENSION:
+		    for (i = 0; i < proprec->prop_len; i++)
+			TxPrintf("%s ", DBWPrintValue(
+				proprec->prop_value.prop_integer[i], w,
+				((i % 2) == 0) ? TRUE : FALSE));
+		
+		    TxPrintf("\n");
+		    break;
+		case PROPERTY_TYPE_PLANE:
+		    DBSrPaintArea(PlaneGetHint(proprec->prop_value.prop_plane),
+				proprec->prop_value.prop_plane,
+				&TiPlaneRect, &CIFSolidBits, printPlanePropFunc,
+				(ClientData)NULL);
+		    TxPrintf("\n");
+		    break;
+		case PROPERTY_TYPE_DOUBLE:
+		    for (i = 0; i < proprec->prop_len; i++)
+			TxPrintf( "%"DLONG_PREFIX"d",
+				proprec->prop_value.prop_double[i]);
+		    TxPrintf("\n");
+		    break;
+	    }
+#endif
+	}
 	else {
 #ifdef MAGIC_WRAPPER
 	    /* If the command was "cellname list property ...", then	*/
 	    /* just return NULL if the property was not found.		*/
-	    if (strcmp(cmd->tx_argv[1], "list"))
+	    if (!dolist)
 #endif
-		TxError("Property name \"%s\" is not defined\n", cmd->tx_argv[1]);
+		TxError("Property name \"%s\" is not defined\n", cmd->tx_argv[argstart]);
 	}
     }
-    else if (locargc == 3)
+    else if (locargc >= 3)
     {
+	/* If the property type was "compat", then set the state of the
+	 * compatibility flag and return.
+	 */
+	if (proptype == PROPERTY_TYPE_COMPAT)
+	{
+	    int idx;
+	    static const char * const cmdPropYesNo[] = {
+			"disable", "no", "false", "off", "0",
+			"enable", "yes", "true", "on", "1", 0 };
+	    idx = Lookup(cmd->tx_argv[2], cmdPropYesNo);
+	    if (idx < 0)
+	    {
+		TxError("Unknown property compat option \"%s\"\n", cmd->tx_argv[2]);
+		return;
+	    }
+	    DBPropCompat = (idx <= 4) ? FALSE : TRUE;
+	    return;
+	}
+
+	/* Catch the following known reserved keywords and cast them to the
+	 * expected property type.  If any property type was already given
+	 * to the command, it is overridden.  This ensures that the reserved
+	 * keyword functions work correctly.
+	 *
+	 * GDS_START, GDS_END:  PROPERTY_TYPE_DOUBLE
+	 * MASKHINTS_*:  PROPERTY_TYPE_PLANE
+	 * FIXED_BBOX:  PROPERTY_TYPE_DIMENSION
+	 */
+	if (!strcmp(cmd->tx_argv[argstart], "GDS_START"))
+	    proptype = PROPERTY_TYPE_DOUBLE;
+	else if (!strcmp(cmd->tx_argv[argstart], "GDS_END"))
+	    proptype = PROPERTY_TYPE_DOUBLE;
+	else if (!strcmp(cmd->tx_argv[argstart], "GDS_FILE"))
+	    proptype = PROPERTY_TYPE_STRING;
+	else if (!strcmp(cmd->tx_argv[argstart], "FIXED_BBOX"))
+	    proptype = PROPERTY_TYPE_DIMENSION;
+	else if (!strcmp(cmd->tx_argv[argstart], "OBS_BBOX"))
+	    proptype = PROPERTY_TYPE_DIMENSION;
+	else if (!strncmp(cmd->tx_argv[argstart], "MASKHINTS_", 10))
+	    proptype = PROPERTY_TYPE_PLANE;
+
 	if (strlen(cmd->tx_argv[argstart + 1]) == 0)
 	    DBPropPut(def, cmd->tx_argv[argstart], NULL);
 	else
 	{
-	    value = StrDup((char **)NULL, cmd->tx_argv[argstart + 1]);
+	    if (proptype == PROPERTY_TYPE_STRING)
-	    DBPropPut(def, cmd->tx_argv[argstart], value);
+	    {
+		proplen = strlen(cmd->tx_argv[argstart + 1]);
+		proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) -
+			7 + proplen);
+		proprec->prop_type = proptype;
+		proprec->prop_len = proplen;
+		strcpy(proprec->prop_value.prop_string, cmd->tx_argv[argstart + 1]);
+	    }
+	    else	/* All non-string properties */
+	    {
+		Plane *plane;
+		Rect r;
+
+		/* Two choices:  If locargc == 3 then all values are in one
+		 * argument.  If locargc > 3, then parse each argument as a
+		 * separate value.
+		 */
+		if (locargc > 3)
+		{
+		    proplen = locargc - 2;
+		    if (proptype == PROPERTY_TYPE_DOUBLE)
+		        proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
+				(proplen - 1)*sizeof(dlong));
+		    else if (proptype == PROPERTY_TYPE_PLANE)
+		    {
+		        proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+			plane = DBNewPlane((ClientData)TT_SPACE);
+			proprec->prop_value.prop_plane = plane;
+		    }
+		    else
+		        proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
+				(proplen - 2)*sizeof(int));
+		    proprec->prop_type = proptype;
+		    proprec->prop_len = proplen;
+
+		    for (i = 1; i < locargc - 1; i++)
+		    {
+			if (proptype == PROPERTY_TYPE_INTEGER)
+			{
+			    if (sscanf(cmd->tx_argv[argstart + i], "%d",
+					&propvalue) == 1)
+				proprec->prop_value.prop_integer[i - 1] = propvalue;
+			    else
+			    {
+				TxError("Unable to parse value \"%s\" as an integer\n",
+					cmd->tx_argv[argstart + i]);
+				proprec->prop_value.prop_integer[i - 1] = 0;
+			    }
+			}
+			else if (proptype == PROPERTY_TYPE_DOUBLE)
+			{
+			    if (sscanf(cmd->tx_argv[argstart + i], "%"DLONG_PREFIX"d",
+					&dvalue) == 1)
+				proprec->prop_value.prop_double[i - 1] = dvalue;
+			    else
+			    {
+				TxError("Unable to parse value \"%s\" as an integer\n",
+					cmd->tx_argv[argstart + i]);
+				proprec->prop_value.prop_double[i - 1] = 0;
+			    }
+			}
+			else if (proptype == PROPERTY_TYPE_PLANE)
+			{
+			    propvalue = cmdParseCoord(w, cmd->tx_argv[argstart + i],
+					FALSE, ((i % 2) == 0) ? FALSE : TRUE);
+			    switch ((i - 1) % 4)
+			    {
+				case 0:
+				    r.r_xbot = propvalue;
+				    break;
+				case 1:
+				    r.r_ybot = propvalue;
+				    break;
+				case 2:
+				    r.r_xtop = propvalue;
+				    break;
+				case 3:
+				    r.r_ytop = propvalue;
+				    DBPaintPlane(plane, &r, CIFPaintTable,
+						(PaintUndoInfo *)NULL);
+				    break;
+			    }
+			}
+			else	/* PROPERTY_TYPE_DIMENSION */
+			{
+			    propvalue = cmdParseCoord(w, cmd->tx_argv[argstart + i],
+					FALSE, ((i % 2) == 0) ? FALSE : TRUE);
+			    proprec->prop_value.prop_integer[i - 1] = propvalue;
+			}
+	 	    }
+		}
+		else
+		{
+		    /* Make two passes through the argument string, once to get
+		     * the valid number of arguments, then again to parse the
+		     * values, once the property record has been allocated
+		     */
+		    if (proptype == PROPERTY_TYPE_PLANE)
+		    {
+		        proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+			plane = DBNewPlane((ClientData)TT_SPACE);
+			proprec->prop_value.prop_plane = plane;
+		    }
+		    else
+		    {
+			value = cmd->tx_argv[argstart + 1];
+			for (proplen = 0; *value != '\0'; )
+			{
+			    if (isspace(*value) && (*value != '\0')) value++;
+			    if (!isspace(*value))
+			    {
+				proplen++;
+				while (!isspace(*value) && (*value != '\0')) value++;
+			    }
+			}
+			if (proplen > 0)
+			    proprec = (PropertyRecord *)mallocMagic(
+					sizeof(PropertyRecord) +
+					(proplen - 2) * sizeof(int));
+		    }
+		    proprec->prop_type = proptype;
+		    proprec->prop_len = proplen;
+
+		    /* Second pass */
+		    value = cmd->tx_argv[argstart + 1];
+		    for (proplen = 0; proplen < proprec->prop_len; proplen++)
+		    {
+			if (isspace(*value) && (*value != '\0')) value++;
+			if (!isspace(*value))
+			{
+			    char *spptr, spchar;
+			    /* cmdParseCoord() can only handle one value at a
+			     * time, so look ahead and null out the next space
+			     * character if there is one.
+			     */
+			    spptr = value + 1;
+			    while (!isspace(*spptr) && (*spptr != '\0')) spptr++;
+			    spchar = *spptr;
+			    *spptr = '\0';
+			
+			    if (proptype == PROPERTY_TYPE_INTEGER)
+			    {
+			        if (sscanf(value, "%d", &propvalue) != 1)
+				{
+				    TxError("Unable to parse integer "
+						"value from \"%s\"\n",
+						value);
+				    propvalue = 0;
+				}
+			        proprec->prop_value.prop_integer[proplen] = propvalue;
+			    }
+			    else if (proptype == PROPERTY_TYPE_DOUBLE)
+			    {
+			        if (sscanf(value, "%"DLONG_PREFIX"d", &dvalue) != 1)
+				{
+				    TxError("Unable to parse integer "
+						"value from \"%s\"\n",
+						value);
+				    propvalue = 0;
+				}
+			        proprec->prop_value.prop_double[proplen] = dvalue;
+			    }
+			    else if (proptype == PROPERTY_TYPE_PLANE)
+			    {
+				propvalue = cmdParseCoord(w, value, FALSE,
+					((proplen % 2) == 0) ? TRUE : FALSE);
+				switch (proplen % 4)
+				{
+				    case 0:
+					r.r_xbot = propvalue;
+					break;
+				    case 1:
+					r.r_ybot = propvalue;
+					break;
+				    case 2:
+					r.r_xtop = propvalue;
+					break;
+				    case 3:
+					r.r_ytop = propvalue;
+					DBPaintPlane(plane, &r, CIFPaintTable,
+						(PaintUndoInfo *)NULL);
+					break;
+				}
+			    }
+			    else	/* PROPERTY_TYPE_DIMENSION */
+			    {
+				propvalue = cmdParseCoord(w, value, FALSE,
+					((proplen % 2) == 0) ? TRUE : FALSE);
+			        proprec->prop_value.prop_integer[proplen] = propvalue;
+			    }
+			    *spptr = spchar;
+			    while (!isspace(*value) && (*value != '\0')) value++;
+			}
+		    }
+		}
+	    }
+	    DBPropPut(def, cmd->tx_argv[argstart], proprec);
 	}
 	def->cd_flags |= (CDMODIFIED | CDGETNEWSTAMP);
     }
@@ -2380,10 +2782,14 @@ CmdDoProperty(
  * defined in database/DBprop.c.
  *
  * Usage:
- *	property [name] [value]
+ *	property [string|integer|dimension] [name] [value]
  *
- * "name" is a unique string tag for the property, and "value" is its
+ * If the first argument is present, it must be one of the known
- * string value.
+ * keywords, and determines the form in which "value" is interpreted and
+ * stored.  "name" is a unique string tag for the property.  "value" is
+ * the value of the property, which is either a string, integer, or a
+ * list of integers.  The difference between an "integer" and a "dimension"
+ * is that all values which are dimensions are scaled with internal units.
  *
  * Results:
  *	None.
@@ -2410,9 +2816,62 @@ CmdProperty(
     else
 	def = ((CellUse *) w->w_surfaceID)->cu_def;
 
-    CmdDoProperty(def, cmd, 1);
+    CmdDoProperty(def, w, cmd, 1);
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ * Callback function for printing values from a Plane property
+ * ----------------------------------------------------------------------------
+ */
+
+#ifdef MAGIC_WRAPPER 
+int
+printPlanePropFunc(
+    Tile *tile,
+    TileType dinfo,
+    Tcl_Obj *lobj)
+{
+    Rect r;
+    MagWindow *w;
+
+    TiToRect(tile, &r);
+    windCheckOnlyWindow(&w, DBWclientID); 
+
+    Tcl_ListObjAppendElement(magicinterp, lobj,
+		Tcl_NewStringObj(DBWPrintValue(r.r_xbot, w, TRUE), -1));
+    Tcl_ListObjAppendElement(magicinterp, lobj,
+		Tcl_NewStringObj(DBWPrintValue(r.r_ybot, w, FALSE), -1));
+    Tcl_ListObjAppendElement(magicinterp, lobj,
+		Tcl_NewStringObj(DBWPrintValue(r.r_xtop, w, TRUE), -1));
+    Tcl_ListObjAppendElement(magicinterp, lobj,
+		Tcl_NewStringObj(DBWPrintValue(r.r_ytop, w, FALSE), -1));
+    return 0;
+}
+
+#else
+
+int
+printPlanePropFunc(
+    Tile *tile,
+    TileType dinfo,
+    ClientData cdata)	/* (unused) */
+{
+    Rect r;
+    MagWindow *w;
+
+    TiToRect(tile, &r);
+    windCheckOnlyWindow(&w, DBWclientID); 
+
+    TxPrintf("%s ", DBWPrintValue(r.r_xbot, w, TRUE));
+    TxPrintf("%s ", DBWPrintValue(r.r_ybot, w, FALSE));
+    TxPrintf("%s ", DBWPrintValue(r.r_xtop, w, TRUE));
+    TxPrintf("%s ", DBWPrintValue(r.r_ytop, w, FALSE));
+    return 0;
+}
+
+#endif
+
 /*
  * ----------------------------------------------------------------------------
  * Callback function for printing a single property key:value pair
@@ -2422,27 +2881,84 @@ CmdProperty(
 int
 printPropertiesFunc(
     const char *name,
-    ClientData value,
+    PropertyRecord *proprec,
-    ClientData cdata) /* not used */
+    MagWindow *w)
 {
-#ifdef MAGIC_WRAPPER
+    int i;
-    char *keyvalue;
 
-    if (value == NULL)
+#ifdef MAGIC_WRAPPER
+    Tcl_Obj *tobj, *lobj;
+
+    tobj = Tcl_GetObjResult(magicinterp);
+    lobj = Tcl_NewListObj(0, NULL);
+    Tcl_ListObjAppendElement(magicinterp, lobj, Tcl_NewStringObj(name, -1));
+
+    switch (proprec->prop_type)
     {
-	keyvalue = (char *)mallocMagic(strlen(name) + 4);
+	case PROPERTY_TYPE_STRING:
-	sprintf(keyvalue, "%s {}", name);
+    	    Tcl_ListObjAppendElement(magicinterp, lobj,
+			Tcl_NewStringObj(proprec->prop_value.prop_string, -1));
+	    break;
+	case PROPERTY_TYPE_INTEGER:
+	    for (i = 0; i < proprec->prop_len; i++)
+    	        Tcl_ListObjAppendElement(magicinterp, lobj,
+			Tcl_NewIntObj(proprec->prop_value.prop_integer[i]));
+	    break;
+	case PROPERTY_TYPE_DIMENSION:
+	    for (i = 0; i < proprec->prop_len; i++)
+    	        Tcl_ListObjAppendElement(magicinterp, lobj,
+			Tcl_NewStringObj(
+			DBWPrintValue(proprec->prop_value.prop_integer[i],
+			w, ((i % 2) == 0) ? TRUE : FALSE), -1));
+	    break;
+	case PROPERTY_TYPE_PLANE:
+	    DBSrPaintArea(PlaneGetHint(proprec->prop_value.prop_plane),
+			proprec->prop_value.prop_plane,
+			&TiPlaneRect, &CIFSolidBits, printPlanePropFunc,
+			(ClientData)lobj);
+	    break;
+	case PROPERTY_TYPE_DOUBLE:
+	    for (i = 0; i < proprec->prop_len; i++)
+    	        Tcl_ListObjAppendElement(magicinterp, lobj,
+			Tcl_NewWideIntObj(proprec->prop_value.prop_double[i]));
+	    break;
     }
-    else
+    Tcl_ListObjAppendElement(magicinterp, tobj, lobj);
-    {
+    Tcl_SetObjResult(magicinterp, tobj);
-	keyvalue = (char *)mallocMagic(strlen(name) + strlen((const char *)value) + 2);
-	sprintf(keyvalue, "%s %s", name, (const char *)value);
-    }
-    Tcl_AppendElement(magicinterp, keyvalue);
-    freeMagic(keyvalue);
 
 #else
-    TxPrintf("%s = %s\n", name, (const char *)value);
+    switch (proprec->prop_type)
+    {
+	case PROPERTY_TYPE_STRING:
+	    TxPrintf("%s = %s\n", name, (const char *)proprec->prop_value.prop_string);
+	    break;
+	case PROPERTY_TYPE_INTEGER:
+	    TxPrintf("%s = ", name);
+	    for (i = 0; i < proprec->prop_len; i++)
+		TxPrintf("%d ", proprec->prop_value.prop_integer[i]);
+	    TxPrintf("\n");
+	    break;
+	case PROPERTY_TYPE_DIMENSION:
+	    TxPrintf("%s = ", name);
+	    for (i = 0; i < proprec->prop_len; i++)
+		TxPrintf("%s ", DBWPrintValue(proprec->prop_value.prop_integer[i],
+			w, ((i % 2) == 0) ? TRUE : FALSE));
+	    TxPrintf("\n");
+	    break;
+	case PROPERTY_TYPE_PLANE:
+    	    TxPrintf("%s = ", name);
+	    DBSrPaintArea((Tile *)NULL, proprec->prop_value.prop_plane,
+			&TiPlaneRect, &CIFSolidBits, printPlanePropFunc,
+			(ClientData)NULL);
+    	    TxPrintf("\n");
+	    break;
+	case PROPERTY_TYPE_DOUBLE:
+	    TxPrintf("%s = ", name);
+	    for (i = 0; i < proprec->prop_len; i++)
+		TxPrintf("%"DLONG_PREFIX"d ", proprec->prop_value.prop_double[i]);
+	    TxPrintf("\n");
+	    break;
+    }
 #endif
 
     return 0;	/* keep the search alive */

commands/CmdRS.c

@@ -1801,13 +1801,18 @@ cmdLabelSizeFunc(
 
     if (value == NULL)
     {
+	char *labsize;
+	MagWindow *w;
+
+	windCheckOnlyWindow(&w, DBWclientID);
+	labsize = DBWPrintValue(label->lab_size / 8, w, FALSE);
+
 #ifdef MAGIC_WRAPPER
 	lobj = Tcl_GetObjResult(magicinterp);
-	Tcl_ListObjAppendElement(magicinterp, lobj,
+	Tcl_ListObjAppendElement(magicinterp, lobj, Tcl_NewStringObj(labsize, -1));
-			Tcl_NewDoubleObj((double)label->lab_size / 8.0));
 	Tcl_SetObjResult(magicinterp, lobj);
 #else
-	TxPrintf("%g\n", (double)label->lab_size / 8.0);
+	TxPrintf("%s\n", labsize);
 #endif
     }
     else if (label->lab_size != *value)
@@ -1952,18 +1957,22 @@ cmdLabelOffsetFunc(
 
     if (point == NULL)
     {
+	char *laboffx, *laboffy;
+	MagWindow *w;
+
+	windCheckOnlyWindow(&w, DBWclientID);
+	laboffx = DBWPrintValue(label->lab_offset.p_x / 8, w, TRUE);
+	laboffy = DBWPrintValue(label->lab_offset.p_x / 8, w, FALSE);
+
 #ifdef MAGIC_WRAPPER
 	lobj = Tcl_GetObjResult(magicinterp);
 	pobj = Tcl_NewListObj(0, NULL);
 	Tcl_ListObjAppendElement(magicinterp, lobj, pobj);
-	Tcl_ListObjAppendElement(magicinterp, pobj,
+	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewStringObj(laboffx, -1));
-			Tcl_NewDoubleObj((double)label->lab_offset.p_x / 8.0));
+	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewStringObj(laboffy, -1));
-	Tcl_ListObjAppendElement(magicinterp, pobj,
-			Tcl_NewDoubleObj((double)label->lab_offset.p_y / 8.0));
 	Tcl_SetObjResult(magicinterp, lobj);
 #else
-	TxPrintf("%g %g\n", (double)(label->lab_offset.p_x) / 8.0,
+	TxPrintf("%s %s\n", laboffx, laboffy);
-		(double)(label->lab_offset.p_y) / 8.0);
 #endif
     }
     else if (!GEO_SAMEPOINT(label->lab_offset, *point))
@@ -2212,9 +2221,13 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+		if (locargc == 2)
-			cmdLabelTextFunc, (locargc == 3) ?
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
-			(ClientData)cmd->tx_argv[argstart + 1] : (ClientData)NULL);
+				cmdLabelTextFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelTextFunc,
+				(ClientData)cmd->tx_argv[argstart + 1]);
 	    }
 	    break;
 
@@ -2280,9 +2293,12 @@ CmdSetLabel(
 		}
 		else if (EditCellUse)
 		{
-		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+		    if (locargc == 2)
-				cmdLabelFontFunc, (locargc == 3) ?
+			SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
-				(ClientData)&font : (ClientData)NULL);
+				cmdLabelFontFunc, (ClientData)NULL);
+		    else
+			SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelFontFunc, (ClientData)&font);
 		}
 	    }
 	    break;
@@ -2310,9 +2326,12 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+		if (locargc == 2)
-			cmdLabelJustFunc, (locargc == 3) ?
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
-			(ClientData)&pos : (ClientData)NULL);
+				cmdLabelJustFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelJustFunc, (ClientData)&pos);
 	    }
 	    break;
 
@@ -2341,9 +2360,12 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+		if (locargc == 2)
-			cmdLabelSizeFunc, (locargc == 3) ?
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
-			(ClientData)&size : (ClientData)NULL);
+				cmdLabelSizeFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelSizeFunc, (ClientData)&size);
 	    }
 	    break;
 
@@ -2393,9 +2415,12 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+		if (locargc == 2)
-			cmdLabelOffsetFunc, (locargc != 2) ?
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
-			(ClientData)&offset : (ClientData)NULL);
+				cmdLabelOffsetFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelOffsetFunc, (ClientData)&offset);
 	    }
 	    break;
 
@@ -2459,10 +2484,12 @@ CmdSetLabel(
 		    rect.r_ytop = cmdScaleCoord(w, cmd->tx_argv[argstart + 4],
 				TRUE, FALSE, 1);
 		}
-		SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+		if ((locargc == 3) || (locargc == 6))
-				cmdLabelRectFunc,
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
-				((locargc == 6) || (locargc == 3)) ?
+				cmdLabelRectFunc, (ClientData)&rect);
-				(ClientData)&rect : (ClientData)NULL);
+		else
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelRectFunc, (ClientData)NULL);
 	    }
 	    break;
 
@@ -2488,9 +2515,12 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+		if (locargc == 2)
-			cmdLabelRotateFunc, (locargc == 3) ?
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
-			(ClientData)&rotate : (ClientData)NULL);
+				cmdLabelRotateFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelRotateFunc, (ClientData)&rotate);
 	    }
 	    break;
 
@@ -2522,9 +2552,12 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
+		if (locargc == 2)
-			cmdLabelStickyFunc, (locargc == 3) ?
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
-			(ClientData)&flags : (ClientData)NULL);
+				cmdLabelStickyFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelStickyFunc, (ClientData)&flags);
 	    }
 	    break;
 
@@ -2563,9 +2596,12 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
+		if (locargc == 2)
-			cmdLabelLayerFunc, (locargc == 3) ?
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
-			(ClientData)&ttype : (ClientData)NULL);
+				cmdLabelLayerFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelLayerFunc, (ClientData)&ttype);
 	    }
 	    break;
 
@@ -2900,6 +2936,29 @@ CmdSnap(
 	TxPrintf("Usage: snap [internal | lambda | user]\n");
 	return;
     }
+
+    /* Backwards compatibility:  Use of "snap" to set units display and
+     * parsing has been deprecated as of February 2026.  However, as this
+     * is rather disruptive to existing scripts which use "snap" to change
+     * the parsing of units, then the following measure is being taken
+     * (for now, anyway):  If DBWUnits is set to DBW_UNITS_DEFAULT, then
+     * "snap internal" will set DBWUnits as well as DBWSnapToGrid.  If
+     * DBWUnits is changed first (e.g., "units internal"), then "snap" will
+     * affect only the snap grid.  The older usage will be accompanied by a
+     * warning message.  Note that backwards compatibility is being kept
+     * only in the case of "snap internal", which was commonly used in
+     * scripts to make sure that all units were interpreted as internal
+     * units.
+     */
+    if ((DBWUnits == DBW_UNITS_DEFAULT) && (n == SNAP_INTERNAL))
+    {
+	DBWUnits = DBW_UNITS_INTERNAL;
+	TxError("Warning:  snap setting is also changing units.  This usage "
+		"is deprecated\nand may be removed in the future.  Use "
+		"\"units\" to change units, and\nchange units before "
+		"setting snap to keep this message from appearing.\n");
+    }
+
     switch (n)
     {
 	case SNAP_OFF: case SNAP_INTERNAL:

commands/CmdSubrs.c

@@ -156,6 +156,9 @@ cmdScaleCoord(
 	 * "snap" setting.  This behavior remains in effect until the "units"
 	 * command is used, in which case units follow the selected units
 	 * value indepedendently of the snap setting.
+	 *
+	 * Updated 12/24/2026 to handle space-separated values (in which
+	 * *endptr may be a space as well as NULL).
 	 */
 	if (DBWUnits == DBW_UNITS_DEFAULT)
 	    curunits = DBWSnapToGrid;
@@ -163,19 +166,22 @@ cmdScaleCoord(
 	    curunits = DBWUnits & DBW_UNITS_TYPE_MASK;
 
 	if ((*endptr == 'l')
-		|| ((*endptr == '\0') && (curunits == DBW_UNITS_LAMBDA)))
+		|| (((*endptr == '\0') || isspace(*endptr))
+		&& (curunits == DBW_UNITS_LAMBDA)))
 	{
 	    /* lambda or default units */
 	    dval *= (double)DBLambda[1];
 	    dval /= (double)DBLambda[0];
 	}
 	else if ((*endptr == 'i')
-		|| ((*endptr == '\0') && (curunits == DBW_UNITS_INTERNAL)))
+		|| (((*endptr == '\0') || isspace(*endptr))
+		&& (curunits == DBW_UNITS_INTERNAL)))
 	{
 	    /* internal units */
 	}
 	else if ((*endptr == 'g')
-		|| ((*endptr == '\0') && (curunits == DBW_UNITS_USER)))
+		|| (((*endptr == '\0') || isspace(*endptr))
+		&& (curunits == DBW_UNITS_USER)))
 	{
 	    /* grid units */
 	    if (w == (MagWindow *)NULL)
@@ -203,11 +209,12 @@ cmdScaleCoord(
 		    dval += (double)crec->dbw_gridRect.r_ybot;
 	    }
 	}
-	else if (*endptr == '\0' && (curunits == DBW_UNITS_MICRONS))
+	else if (((*endptr == '\0') || isspace(*endptr))
+		&& (curunits == DBW_UNITS_MICRONS))
 	{
 	    mscale = 1000;
 	}
-	else
+	else if (*endptr != '\0')
 	{
 	    /* natural units referred to the current cifoutput style */
 	    if (*(endptr + 1) == 'm')
@@ -249,7 +256,7 @@ cmdScaleCoord(
 		mscale = -1;
 	    }
 	}
-	if ((mscale != -1) && !isspace(*endptr))
+	if (mscale != -1)
 	    dval /= CIFGetOutputScale(mscale);
 	curval = round(dval);
 
@@ -297,9 +304,13 @@ cmdScaleCoord(
 		    parseop = PARSEOP_DIV;
 		    endptr++;
 		    break;
-		default:
+		case ' ':
+		case '\t':
 		    endptr++;
 		    break;
+		default:
+		    /* Should this flag an error? */
+		    return retval;
 	    }
 	    if (parseop != PARSEOP_NONE) break;
 	}
@@ -750,13 +761,16 @@ cmdSaveCell(
     if (!tryRename || (fileName == NULL) || (strcmp(cellDef->cd_name, fileName) == 0))
 	goto cleanup;
 
-    /* Rename the cell */
+    /* Rename the cell, unless fileName is a .tcl file (scripted output) */
-    if (!DBCellRenameDef(cellDef, fileName))
+    if ((strlen(fileName) <= 4) || strcmp(fileName + strlen(fileName) - 4, ".tcl"))
     {
-	/* This should never happen */
+	if (!DBCellRenameDef(cellDef, fileName))
-	TxError("Magic error: there is already a cell named \"%s\"\n",
+	{
+	    /* This should never happen */
+	    TxError("Magic error: there is already a cell named \"%s\"\n",
 		    fileName);
-	goto cleanup;
+	    goto cleanup;
+	}
     }
 
     if (EditCellUse && (cellDef == EditCellUse->cu_def))
@@ -1225,7 +1239,7 @@ cmdExpandOneLevel(
     extern int cmdExpand1func(CellUse *cu, ClientData bitmask);
 
     /* first, expand this cell use */
-    DBExpand(cu, bitmask, expand);
+    DBExpand(cu, bitmask, expand ? DB_EXPAND : DB_UNEXPAND);
 
     /* now, unexpand its direct children (ONE LEVEL ONLY) */
     if (expand)
@@ -1237,7 +1251,7 @@ cmdExpand1func(
     CellUse *cu,
     ClientData bitmask)
 {
-    DBExpand(cu, (int)CD2INT(bitmask), FALSE);
+    DBExpand(cu, (int)CD2INT(bitmask), DB_UNEXPAND);
     return 0;
 }
 

commands/CmdTZ.c

@@ -702,32 +702,62 @@ CmdTool(
  * Implement the "unexpand" command.
  *
  * Usage:
- *	unexpand
+ *	unexpand [selection|surround|overlap|all]
+ *
+ *	"selection" unexpands (hides) cells in the selection.  All
+ *	other options unexpand cells in the layout.  "all" unexpands
+ *	all cells in the layout.  "surround" unexpannds cells which
+ *	the cursor box surrounds completely, and "overlap" unexpands
+ *	cells which the cursor box overlaps.
+ *
+ *	For backwards compatibility:
+ *	"unexpand" alone implements "unexpand surround".
+ *
+ *	Also see:  CmdExpand
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Unexpands all cells under the box that don't completely
+ *	Changes the expansion state of cells.
- *	contain the box.
  *
  * ----------------------------------------------------------------------------
  */
 
+#define UNEXPAND_SELECTION	0
+#define UNEXPAND_SURROUND	1
+#define UNEXPAND_OVERLAP	2
+#define UNEXPAND_ALL		3
+#define UNEXPAND_HELP		4
+
 void
 CmdUnexpand(
     MagWindow *w,
     TxCommand *cmd)
 {
-    int windowMask, boxMask;
+    int windowMask, boxMask, option;
+    const char * const *msg;
     Rect rootRect;
+
     int cmdUnexpandFunc(CellUse *use, int windowMask);		/* Forward reference. */
 
-    if (cmd->tx_argc != 1)
+    static const char * const cmdUnexpandOption[] = {
+	"selection	expand cell instances in the selection",
+	"surround	expand cell instances which the cursor box surrounds",
+	"overlap	expand cell instances which the cursor box overlaps",
+	"all		expand all cell instances",
+	NULL
+    };
+
+    if (cmd->tx_argc > 1)
     {
-	TxError("Usage: %s\n", cmd->tx_argv[0]);
+	option = Lookup(cmd->tx_argv[1], cmdUnexpandOption);
-	return;
+	if (option < 0) option = UNEXPAND_HELP;
     }
+    else
+	option = UNEXPAND_SURROUND;
+
+    if (option == UNEXPAND_HELP) goto badusage; 
 
     windCheckOnlyWindow(&w, DBWclientID);
     if (w == (MagWindow *) NULL)
@@ -743,8 +773,42 @@ CmdUnexpand(
 	TxError("The box isn't in the same window as the cursor.\n");
 	return;
     }
-    DBExpandAll(((CellUse *) w->w_surfaceID), &rootRect, windowMask,
+
-	    FALSE, cmdUnexpandFunc, (ClientData)(pointertype) windowMask);
+    switch (option)
+    {
+	case UNEXPAND_SELECTION:
+	    SelectExpand(windowMask, DB_UNEXPAND, (Rect *)NULL, FALSE);
+	    break;
+	case UNEXPAND_OVERLAP:
+	    DBExpandAll(((CellUse *)w->w_surfaceID), &rootRect, windowMask,
+			DB_UNEXPAND | DB_EXPAND_OVERLAP,
+			cmdUnexpandFunc, (ClientData)(pointertype)windowMask);
+	    SelectExpand(windowMask,
+			DB_UNEXPAND | DB_EXPAND_OVERLAP,
+			&rootRect, FALSE);
+	    break;
+	case UNEXPAND_SURROUND:
+	    DBExpandAll(((CellUse *)w->w_surfaceID), &rootRect, windowMask,
+			DB_UNEXPAND | DB_EXPAND_SURROUND,
+			cmdUnexpandFunc, (ClientData)(pointertype)windowMask);
+	    SelectExpand(windowMask,
+			DB_UNEXPAND | DB_EXPAND_SURROUND,
+			&rootRect, TRUE);
+	    break;
+	case UNEXPAND_ALL:
+	    DBExpandAll(((CellUse *)w->w_surfaceID), &TiPlaneRect, windowMask,
+			DB_UNEXPAND | DB_EXPAND_OVERLAP,
+			cmdUnexpandFunc, (ClientData)(pointertype)windowMask);
+	    SelectExpand(windowMask,
+			DB_UNEXPAND | DB_EXPAND_OVERLAP,
+			(Rect *)NULL);
+	    break;
+    }
+    return;
+
+badusage:
+    for (msg = &(cmdUnexpandOption[0]); *msg != NULL; msg++)
+        TxPrintf("    %s\n", *msg);
 }
 
 /* This function is called for each cell whose expansion status changed.

commands/commands.h

@@ -72,7 +72,7 @@ extern int cmdParseCoord(MagWindow *w, char *arg, bool is_relative, bool is_x);
 extern void cmdSaveCell(CellDef *cellDef, char *newName, bool noninteractive, bool tryRename);
 extern void CmdInit(void);
 
-extern void CmdDoProperty(CellDef *def, TxCommand *cmd, int argstart);
+extern void CmdDoProperty(CellDef *def, MagWindow *w, TxCommand *cmd, int argstart);
 extern void CmdPaintEraseButton(MagWindow *w, Point *refPoint, bool isPaint, bool isScreen);
 
 #endif /* _MAGIC__COMMANDS__COMMANDS_H */

database/DBcellcopy.c

@@ -37,9 +37,8 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include "windows/windows.h"
 #include "dbwind/dbwind.h"
 #include "commands/commands.h"
-
-/* C99 compat */
 #include "graphics/graphics.h"
+#include "cif/CIFint.h"
 
 /*
  * The following variable points to the tables currently used for
@@ -357,9 +356,43 @@ DBCellCheckCopyAllPaint(scx, mask, xMask, targetUse, func)
 struct propUseDefStruct {
    CellDef *puds_source;
    CellDef *puds_dest;
+   Plane *puds_plane;		/* Mask hint plane in dest */
    Transform *puds_trans;	/* Transform from source use to dest */
+   Rect *puds_area;		/* Clip area in source coordinates */
 };
 
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * dbCopyMaskHintPlaneFunc --
+ *
+ *	Translate tiles from a child mask-hint property plane into the
+ *	coordinate system of the parent, and paint the mask-hint area
+ *	into the mask-hint property plane of the parent.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+int
+dbCopyMaskHintPlaneFunc(Tile *tile,
+    TileType dinfo,
+    struct propUseDefStruct *puds)
+{
+    Transform *trans = puds->puds_trans;
+    Rect *clip = puds->puds_area;
+    Rect r, rnew;
+    Plane *plane = puds->puds_plane;
+    
+    TiToRect(tile, &r);
+    GeoClip(&r, clip);
+    if (!GEO_RECTNULL(&r))
+    {
+	GeoTransRect(trans, &r, &rnew);
+	DBPaintPlane(plane, &rnew, CIFPaintTable, (PaintUndoInfo *)NULL);
+    }
+    return 0;
+}
+
 /*
  *-----------------------------------------------------------------------------
  *
@@ -380,63 +413,52 @@ struct propUseDefStruct {
  */
 
 int
-dbCopyMaskHintsFunc(key, value, puds)
+dbCopyMaskHintsFunc(key, proprec, puds)
     char *key;
-    ClientData value;
+    PropertyRecord *proprec;
     struct propUseDefStruct *puds;
 {
     CellDef *dest = puds->puds_dest;
     Transform *trans = puds->puds_trans;
-    char *propstr = (char *)value;
+    Rect *clip = puds->puds_area;
+    PropertyRecord *parentproprec, *newproprec;
     char *parentprop, *newvalue, *vptr;
     Rect r, rnew;
     bool propfound;
+    int i, j;
 
     if (!strncmp(key, "MASKHINTS_", 10))
     {
 	char *vptr, *lastval;
 	int lastlen;
+	Plane *plane;
 
-	/* Append to existing mask hint (if any) */
+	ASSERT(proprec->prop_type == PROPERTY_TYPE_PLANE, "dbCopyMaskHintsFunc");
-	parentprop = (char *)DBPropGet(dest, key, &propfound);
-	newvalue = (propfound) ? StrDup((char **)NULL, parentprop) : (char *)NULL;
 
-	vptr = propstr;
+	/* Get the existing mask hint plane in the parent cell, and
-	while (*vptr != '\0')
+	 * create it if it does not already exist.
+	 */
+	parentproprec = (PropertyRecord *)DBPropGet(dest, key, &propfound);
+
+	if (propfound)
+	    plane = parentproprec->prop_value.prop_plane;
+	else
 	{
-	    if (sscanf(vptr, "%d %d %d %d", &r.r_xbot, &r.r_ybot,
+	    newproprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
-			&r.r_xtop, &r.r_ytop) == 4)
+	    newproprec->prop_type = PROPERTY_TYPE_PLANE;
-	    {
+	    newproprec->prop_len = 0;
-		GeoTransRect(trans, &r, &rnew);
+	    plane = DBNewPlane((ClientData)TT_SPACE);
-
+	    newproprec->prop_value.prop_plane = plane;
-		lastval = newvalue;
+	    DBPropPut(dest, key, newproprec);
-		lastlen = (lastval) ? strlen(lastval) : 0;
-		newvalue = mallocMagic(40 + lastlen);
-
-		if (lastval)
-		    strcpy(newvalue, lastval);
-		else
-		    *newvalue = '\0';
-
-		sprintf(newvalue + lastlen, "%s%d %d %d %d", (lastval) ?  " " : "",
-			rnew.r_xbot, rnew.r_ybot, rnew.r_xtop, rnew.r_ytop);
-		if (lastval) freeMagic(lastval);
-
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-	    }
-	    else break;
 	}
-	if (newvalue)
+	puds->puds_plane = plane;
-	    DBPropPut(dest, key, newvalue);
-    }
 
+	/* Copy the properties from child to parent */
+	DBSrPaintArea(PlaneGetHint(proprec->prop_value.prop_plane),
+		proprec->prop_value.prop_plane,
+		clip, &CIFSolidBits, dbCopyMaskHintPlaneFunc, 
+		(ClientData)puds);
+    }
     return 0;
 }
 
@@ -468,6 +490,7 @@ DBCellCopyMaskHints(child, parent, transform)
     puds.puds_source = child->cu_def;
     puds.puds_dest = parent;
     puds.puds_trans = transform;
+    puds.puds_area = (Rect *)&TiPlaneRect;
     DBPropEnum(child->cu_def, dbCopyMaskHintsFunc, (ClientData)&puds);
 }
 
@@ -501,6 +524,7 @@ dbFlatCopyMaskHintsFunc(scx, def)
     puds.puds_source = scx->scx_use->cu_def;
     puds.puds_dest = def;
     puds.puds_trans = &scx->scx_trans;
+    puds.puds_area = &scx->scx_area;
 
     DBPropEnum(use->cu_def, dbCopyMaskHintsFunc, (ClientData)&puds);
 

database/DBcellname.c

@@ -152,10 +152,9 @@ DBCellRename(cellname, newname, doforce)
 
     if (doforce && ((celldef->cd_flags & CDVENDORGDS) == CDVENDORGDS))
     {
-	char *chkgdsfile;
 	bool isReadOnly;
 
-	chkgdsfile = (char *)DBPropGet(celldef, "GDS_FILE", &isReadOnly);
+	DBPropGet(celldef, "GDS_FILE", &isReadOnly);
 	/* Note that clearing GDS_FILE will also clear CDVENDORGDS flag */
 	if (isReadOnly) DBPropPut(celldef, "GDS_FILE", NULL);
 
@@ -1620,6 +1619,7 @@ dbAbutmentUseFunc(selUse, use, transform, data)
 {
     Rect bbox, refbox;
     Transform *trans;
+    PropertyRecord *proprec;
     char *propvalue;
     char *refllx, *reflly, *refurx, *refury;
     bool found;
@@ -1643,14 +1643,25 @@ dbAbutmentUseFunc(selUse, use, transform, data)
     }
 
     trans = &use->cu_transform;
-    propvalue = (char *)DBPropGet(use->cu_def, "FIXED_BBOX", &found);
+    proprec = DBPropGet(use->cu_def, "FIXED_BBOX", &found);
     if (!found)
 	bbox = use->cu_def->cd_bbox;
     else
     {
-	if (sscanf(propvalue, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
+	if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
-		&bbox.r_xtop, &bbox.r_ytop) != 4)
+		(proprec->prop_len == 4))
+	{
+	    bbox.r_xbot = proprec->prop_value.prop_integer[0];
+	    bbox.r_ybot = proprec->prop_value.prop_integer[1];
+	    bbox.r_xtop = proprec->prop_value.prop_integer[2];
+	    bbox.r_ytop = proprec->prop_value.prop_integer[3];
+	}
+	else
+	{
+	    TxError("Unable to parse the cell's FIXED_BBOX property; using "
+			"the instance bounding box instead.\n");
 	    bbox = use->cu_def->cd_bbox;
+	}
     }
     GeoTransRect(trans, &bbox, &refbox);
 

database/DBcellsrch.c

@@ -588,6 +588,25 @@ DBTreeSrLabels(scx, mask, xMask, tpath, flags, func, cdarg)
 	if (!DBCellRead(def, TRUE, TRUE, NULL))
 	    return 0;
 
+    if (flags & TF_LABEL_REVERSE_SEARCH)
+    {
+	/* Search children first */
+	filter.tf_func = func;
+	filter.tf_arg = cdarg;
+	filter.tf_mask = mask;
+	filter.tf_xmask = xMask;
+	filter.tf_tpath = tpath;
+	filter.tf_flags = flags;
+
+	scx2 = *scx;
+	if (scx2.scx_area.r_xbot > TiPlaneRect.r_xbot) scx2.scx_area.r_xbot -= 1;
+	if (scx2.scx_area.r_ybot > TiPlaneRect.r_ybot) scx2.scx_area.r_ybot -= 1;
+	if (scx2.scx_area.r_xtop < TiPlaneRect.r_xtop) scx2.scx_area.r_xtop += 1;
+	if (scx2.scx_area.r_ytop < TiPlaneRect.r_ytop) scx2.scx_area.r_ytop += 1;
+	if (DBCellSrArea(&scx2, dbCellLabelSrFunc, (ClientData) &filter))
+	    return 1;
+    }
+
     for (lab = def->cd_labels; lab; lab = lab->lab_next)
     {
 	if (SigInterruptPending) break;
@@ -640,6 +659,8 @@ DBTreeSrLabels(scx, mask, xMask, tpath, flags, func, cdarg)
 		return (1);
     }
 
+    if (flags & TF_LABEL_REVERSE_SEARCH) return 0;  /* children already searched */
+
     filter.tf_func = func;
     filter.tf_arg = cdarg;
     filter.tf_mask = mask;
@@ -711,6 +732,16 @@ dbCellLabelSrFunc(scx, fp)
 	}
     }
 
+    /* If fp->tf_flags has TF_LABEL_REVERSE_SEARCH, then search child
+     * uses first, then the parent.  This is for display, so that if
+     * a child cell and parent cell have overlapping labels, the parent
+     * label is the one on top.
+     */
+
+    if (fp->tf_flags & TF_LABEL_REVERSE_SEARCH)
+	if (DBCellSrArea(scx, dbCellLabelSrFunc, (ClientData) fp))
+	    result = 1;
+
     /* Apply the function first to any of the labels in this def. */
 
     result = 0;
@@ -732,9 +763,11 @@ dbCellLabelSrFunc(scx, fp)
 	}
     }
 
-    /* Now visit each child use recursively */
+    /* Now visit each child use recursively, if not doing a reverse search */
-    if (DBCellSrArea(scx, dbCellLabelSrFunc, (ClientData) fp))
+
-	result = 1;
+    if (!(fp->tf_flags & TF_LABEL_REVERSE_SEARCH))
+	if (DBCellSrArea(scx, dbCellLabelSrFunc, (ClientData) fp))
+	    result = 1;
 
 cleanup:
     /* Remove the trailing pathname component from the TerminalPath */
@@ -1713,7 +1746,7 @@ dbTileMoveFunc(tile, dinfo, mvvals)
     if (IsSplit(tile))
 	type = (dinfo & TT_SIDE) ? SplitRightType(tile) : SplitLeftType(tile);
     DBNMPaintPlane(mvvals->ptarget, exact, &targetRect,
-		DBStdPaintTbl(type, mvvals->pnum),
+		(mvvals->pnum < 0) ? CIFPaintTable : DBStdPaintTbl(type, mvvals->pnum),
 		(PaintUndoInfo *)NULL);
     return 0;
 }
@@ -1806,84 +1839,48 @@ typedef struct _cellpropstruct {
  * ----------------------------------------------------------------------------
  */
 
-int dbScaleProp(name, value, cps)
+int dbScaleProp(name, proprec, cps)
     char *name;
-    char *value;
+    PropertyRecord *proprec;
     CellPropStruct *cps;
 {
-    int scalen, scaled;
+    int i, scalen, scaled;
-    char *newvalue, *vptr;
+    Point p;
-    Rect r;
 
-    if ((strlen(name) > 5) && !strncmp(name + strlen(name) - 5, "_BBOX", 5))
+    /* Only "dimension" and "plane" type properties get scaled */
+
+    if (proprec->prop_type == PROPERTY_TYPE_PLANE)
     {
-	if (sscanf(value, "%d %d %d %d", &r.r_xbot, &r.r_ybot,
+	Plane *newplane;
-			&r.r_xtop, &r.r_ytop) == 4)
+	newplane = DBNewPlane((ClientData)TT_SPACE);
-	{
+	DBClearPaintPlane(newplane);
-	    /* Scale numerator held in point X value, */
+	/* Plane index is unused;  arbitrarily substitute -1 */
-	    /* scale denominator held in point Y value */
+	dbScalePlane(proprec->prop_value.prop_plane, newplane, -1,
-
+			scalen, scaled, TRUE);
-	    scalen = cps->cps_point.p_x;
+	DBFreePaintPlane(proprec->prop_value.prop_plane);
-	    scaled = cps->cps_point.p_y;
+	TiFreePlane(proprec->prop_value.prop_plane);
-
+	proprec->prop_value.prop_plane = newplane;
-	    DBScalePoint(&r.r_ll, scalen, scaled);
+	return 0;
-	    DBScalePoint(&r.r_ur, scalen, scaled);
-
-	    newvalue = (char *)mallocMagic(40);
-	    sprintf(newvalue, "%d %d %d %d", r.r_xbot, r.r_ybot,
-			r.r_xtop, r.r_ytop);
-	    DBPropPut(cps->cps_def, name, newvalue);
-	}
     }
-    else if (!strncmp(name, "MASKHINTS_", 10))
+
+    if (proprec->prop_type != PROPERTY_TYPE_DIMENSION) return 0; 
+
+    /* Scale numerator held in point X value, */
+    /* scale denominator held in point Y value */
+    scalen = cps->cps_point.p_x;
+    scaled = cps->cps_point.p_y;
+
+    for (i = 0; i < proprec->prop_len; i += 2)
     {
-	char *vptr, *lastval;
+	if ((i + 1) >= proprec->prop_len) break;
-	int lastlen;
 
-	newvalue = (char *)NULL;
+	p.p_x = proprec->prop_value.prop_integer[i];
-	vptr = value;
+	p.p_y = proprec->prop_value.prop_integer[i + 1];
-	while (*vptr != '\0')
+	DBScalePoint(&p, scalen, scaled);
-	{
+	proprec->prop_value.prop_integer[i] = p.p_x;
-	    if (sscanf(vptr, "%d %d %d %d", &r.r_xbot, &r.r_ybot,
+	proprec->prop_value.prop_integer[i + 1] = p.p_y;
-			&r.r_xtop, &r.r_ytop) == 4)
-	    {
-	    	/* Scale numerator held in point X value, */
-	    	/* scale denominator held in point Y value */
-
-	    	scalen = cps->cps_point.p_x;
-	    	scaled = cps->cps_point.p_y;
-
-	    	DBScalePoint(&r.r_ll, scalen, scaled);
-	    	DBScalePoint(&r.r_ur, scalen, scaled);
-
-		lastval = newvalue;
-		lastlen = (lastval) ? strlen(lastval) : 0;
-		newvalue = mallocMagic(40 + lastlen);
-
-		if (lastval)
-		    strcpy(newvalue, lastval);
-		else
-		    *newvalue = '\0';
-
-		sprintf(newvalue + lastlen, "%s%d %d %d %d", (lastval) ? " " : "",
-			r.r_xbot, r.r_ybot, r.r_xtop, r.r_ytop);
-		if (lastval) freeMagic(lastval);
-
-		/* Parse through the four values and check if there's more */
-                while (*vptr && !isspace(*vptr)) vptr++;
-                while (*vptr && isspace(*vptr)) vptr++;
-                while (*vptr && !isspace(*vptr)) vptr++;
-                while (*vptr && isspace(*vptr)) vptr++;
-                while (*vptr && !isspace(*vptr)) vptr++;
-                while (*vptr && isspace(*vptr)) vptr++;
-                while (*vptr && !isspace(*vptr)) vptr++;
-                while (*vptr && isspace(*vptr)) vptr++;
-	    }
-	    else break;
-	}
-	if (newvalue)
-	    DBPropPut(cps->cps_def, name, newvalue);
     }
+
     return 0;	/* Keep enumerating through properties */
 }
 
@@ -1899,33 +1896,47 @@ int dbScaleProp(name, value, cps)
  * ----------------------------------------------------------------------------
  */
 
-int dbMoveProp(name, value, cps)
+int dbMoveProp(name, proprec, cps)
     char *name;
-    char *value;
+    PropertyRecord *proprec;
     CellPropStruct *cps;
 {
-    int origx, origy;
+    int i, origx, origy;
     char *newvalue;
-    Rect r;
+    Point p;
 
-    if (((strlen(name) > 5) && !strncmp(name + strlen(name) - 5, "_BBOX", 5))
+    /* Only "dimension" and "plane" type properties get scaled */
-		|| !strncmp(name, "MASKHINTS_", 10))
+
+    if (proprec->prop_type == PROPERTY_TYPE_PLANE)
     {
-	if (sscanf(value, "%d %d %d %d", &r.r_xbot, &r.r_ybot,
+	Plane *newplane;
-			&r.r_xtop, &r.r_ytop) == 4)
-	{
-	    origx = cps->cps_point.p_x;
-	    origy = cps->cps_point.p_y;
 
-	    DBMovePoint(&r.r_ll, origx, origy);
+	newplane = DBNewPlane((ClientData) TT_SPACE);
-	    DBMovePoint(&r.r_ur, origx, origy);
+	DBClearPaintPlane(newplane);
-
+	/* Use plane index -1 to indicate use of CIFPaintTable */
-	    newvalue = (char *)mallocMagic(40);
+	dbMovePlane(proprec->prop_value.prop_plane, newplane, -1, origx, origy);
-	    sprintf(newvalue, "%d %d %d %d", r.r_xbot, r.r_ybot,
+        DBFreePaintPlane(proprec->prop_value.prop_plane);
-			r.r_xtop, r.r_ytop);
+	TiFreePlane(proprec->prop_value.prop_plane);
-	    DBPropPut(cps->cps_def, name, newvalue);
+        proprec->prop_value.prop_plane = newplane;
-	}
+	return 0;
     }
+
+    if (proprec->prop_type != PROPERTY_TYPE_DIMENSION) return 0; 
+
+    origx = cps->cps_point.p_x;
+    origy = cps->cps_point.p_y;
+
+    for (i = 0; i < proprec->prop_len; i += 2)
+    {
+	if ((i + 1) >= proprec->prop_len) break;
+
+	p.p_x = proprec->prop_value.prop_integer[i];
+	p.p_y = proprec->prop_value.prop_integer[i + 1];
+	DBMovePoint(&p, origx, origy);
+	proprec->prop_value.prop_integer[i] = p.p_x;
+	proprec->prop_value.prop_integer[i + 1] = p.p_y;
+    }
+
     return 0;	/* Keep enumerating through properties */
 }
 

database/DBexpand.c

@@ -39,6 +39,7 @@ struct expandArg
 {
     bool	ea_deref;	/* TRUE if root def dereference flag is set */
     int		ea_xmask;	/* Expand mask. */
+    int		ea_type;	/* Expand, unexpand, or toggle */
     int		(*ea_func)();	/* Function to call for each cell whose
 				 * status is changed.
 				 */
@@ -67,15 +68,22 @@ struct expandArg
  */
 
 void
-DBExpand(cellUse, expandMask, expandFlag)
+DBExpand(cellUse, expandMask, expandType)
     CellUse *cellUse;
     int expandMask;
-    bool expandFlag;
+    int expandType;
 {
     CellDef *def;
-
+    bool expandFlag, expandTest;
-    if (DBDescendSubcell(cellUse, expandMask) == expandFlag)
+ 
-	return;
+    expandTest = DBDescendSubcell(cellUse, expandMask);
+    if ((expandType & DB_EXPAND_MASK) == DB_EXPAND_TOGGLE)
+	expandFlag = expandTest;
+    else
+    {
+	expandFlag = ((expandType & DB_EXPAND_MASK) == DB_EXPAND) ? TRUE : FALSE;
+	if (expandFlag == expandTest) return;
+    }
 
     if (expandFlag)
     {
@@ -130,17 +138,17 @@ DBExpand(cellUse, expandMask, expandFlag)
  */
 
 void
-DBExpandAll(rootUse, rootRect, expandMask, expandFlag, func, cdarg)
+DBExpandAll(rootUse, rootRect, expandMask, expandType, func, cdarg)
     CellUse *rootUse;	/* Root cell use from which search begins */
     Rect *rootRect;	/* Area to be expanded, in root coordinates */
     int expandMask;	/* Window mask in which cell is to be expanded */
-    bool expandFlag;	/* TRUE => expand, FALSE => unexpand */
+    int expandType;	/* DB_EXPAND, DB_UNEXPAND, DB_EXPAND_TOGGLE */
     int (*func)();	/* Function to call for each cell whose expansion
 			 * status is modified.  NULL means don't call anyone.
 			 */
     ClientData cdarg;	/* Argument to pass to func. */
 {
-    int dbExpandFunc(), dbUnexpandFunc();
+    int dbExpandFunc();
     SearchContext scontext;
     struct expandArg arg;
 
@@ -148,29 +156,26 @@ DBExpandAll(rootUse, rootRect, expandMask, expandFlag, func, cdarg)
 	(void) DBCellRead(rootUse->cu_def, TRUE, TRUE, NULL);
 
     /*
-     * Walk through the area and set the expansion state
+     * Walk through the area and set the expansion state appropriately.
-     * appropriately.
      */
 
     arg.ea_xmask = expandMask;
     arg.ea_func = func;
     arg.ea_arg = cdarg;
+    arg.ea_type = expandType;
     arg.ea_deref = (rootUse->cu_def->cd_flags & CDDEREFERENCE) ? TRUE : FALSE;
 
     scontext.scx_use = rootUse;
     scontext.scx_trans = GeoIdentityTransform;
     scontext.scx_area = *rootRect;
-    if (expandFlag)
+    DBCellSrArea(&scontext, dbExpandFunc, (ClientData) &arg);
-	DBCellSrArea(&scontext, dbExpandFunc, (ClientData) &arg);
-    else
-	DBCellSrArea(&scontext, dbUnexpandFunc, (ClientData) &arg);
 }
 
 /*
  * dbExpandFunc --
  *
  * Filter function called by DBCellSrArea on behalf of DBExpandAll above
- * when cells are being expanded.
+ * when cells are being expanded, unexpanded, or toggled.
  */
 
 int
@@ -184,68 +189,55 @@ dbExpandFunc(scx, arg)
 {
     CellUse *childUse = scx->scx_use;
     int n = DBLambda[1];
+    int expandTest;
+    int expandType = (arg->ea_type & DB_EXPAND_MASK);
+    int expandSurround = (arg->ea_type & DB_EXPAND_SURROUND_MASK);
+    bool surround;
+
+    expandTest = DBDescendSubcell(childUse, arg->ea_xmask);
 
     /*
      * Change the expansion status of this cell if necessary.  Call the
      * client's function if the expansion status has changed.
      */
 
-    if (!DBDescendSubcell(childUse, arg->ea_xmask))
+    if (!expandTest && ((expandType == DB_EXPAND) || (expandType == DB_EXPAND_TOGGLE)))
     {
-	/* If the cell is unavailable, then don't expand it.
+	surround = (!GEO_SURROUND(&childUse->cu_def->cd_bbox, &scx->scx_area)
-	 */
+			|| GEO_SURROUND(&scx->scx_area, &childUse->cu_def->cd_bbox));
-	if ((childUse->cu_def->cd_flags & CDAVAILABLE) == 0)
+	if (surround || (expandSurround == DB_EXPAND_OVERLAP))
 	{
-	    /* If the parent is dereferenced, then the child should be, too */
+	    /* If the cell is unavailable, then don't expand it.
-	    if (arg->ea_deref) childUse->cu_def->cd_flags |= CDDEREFERENCE;
+	     */
-	    if(!DBCellRead(childUse->cu_def, TRUE, TRUE, NULL))
+	    if ((childUse->cu_def->cd_flags & CDAVAILABLE) == 0)
 	    {
-		TxError("Cell %s is unavailable.  It could not be expanded.\n",
+		/* If the parent is dereferenced, then the child should be, too */
-			childUse->cu_def->cd_name);
+		if (arg->ea_deref) childUse->cu_def->cd_flags |= CDDEREFERENCE;
-		return 2;
+		if (!DBCellRead(childUse->cu_def, TRUE, TRUE, NULL))
+		{
+		    TxError("Cell %s is unavailable.  It could not be expanded.\n",
+				childUse->cu_def->cd_name);
+		    return 2;
+		}
+	    }
+
+	    childUse->cu_expandMask |= arg->ea_xmask;
+	    expandTest = TRUE;
+	    if (arg->ea_func != NULL)
+	    {
+		if ((*arg->ea_func)(childUse, arg->ea_arg) != 0) return 1;
 	    }
 	}
-
-	childUse->cu_expandMask |= arg->ea_xmask;
-	if (arg->ea_func != NULL)
-	{
-	    if ((*arg->ea_func)(childUse, arg->ea_arg) != 0) return 1;
-	}
     }
-
+    else if (expandTest && ((expandType == DB_UNEXPAND) ||
-    if (DBCellSrArea(scx, dbExpandFunc, (ClientData) arg))
+			(expandType == DB_EXPAND_TOGGLE)))
-	return 1;
-    return 2;
-}
-
-/*
- * dbUnexpandFunc --
- *
- * Filter function called by DBCellSrArea on behalf of DBExpandAll above
- * when cells are being unexpanded.
- */
-
-int
-dbUnexpandFunc(scx, arg)
-    SearchContext *scx;	/* Pointer to search context containing
-					 * child use, search area in coor-
-					 * dinates of the child use, and
-					 * transform back to "root".
-					 */
-    struct expandArg *arg;	/* Client data from caller */
-{
-    CellUse *childUse = scx->scx_use;
-
-    /*
-     * Change the expansion status of this cell if necessary.
-     */
-
-    if (DBDescendSubcell(childUse, arg->ea_xmask))
     {
-	if (!GEO_SURROUND(&childUse->cu_def->cd_bbox, &scx->scx_area)
+	surround = (!GEO_SURROUND(&childUse->cu_def->cd_bbox, &scx->scx_area)
-	    || GEO_SURROUND(&scx->scx_area, &childUse->cu_def->cd_bbox))
+			|| GEO_SURROUND(&scx->scx_area, &childUse->cu_def->cd_bbox));
+	if (surround || (expandSurround == DB_EXPAND_OVERLAP))
 	{
 	    childUse->cu_expandMask &= ~arg->ea_xmask;
+	    expandTest = FALSE;
 
 	    /* Call the client's function, if there is one. */
 
@@ -256,11 +248,7 @@ dbUnexpandFunc(scx, arg)
 	}
     }
 
-    /* Don't recursively search things that aren't already expanded. */
+    if (DBCellSrArea(scx, dbExpandFunc, (ClientData) arg))
-
-    else return 2;
-
-    if (DBCellSrArea(scx, dbUnexpandFunc, (ClientData) arg))
 	return 1;
     return 2;
 }

database/DBprop.c

@@ -32,6 +32,16 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include "database/database.h"
 #include "utils/malloc.h"
 
+/* Global variable */
+
+bool DBPropCompat = TRUE;	/* If TRUE, then always save properties to
+				 * .mag files as type "string" for backwards
+				 * compatibility.  If FALSE, then properties
+				 * are saved to the .mag file along with their
+				 * type.  Regardless of the setting, properties
+				 * which are reserved keywords are converted
+				 * to the best internal representation on input.
+				 */
 
 /* ----------------------------------------------------------------------------
  *
@@ -47,16 +57,16 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 
 void
 DBPropPut(cellDef, name, value)
-    CellDef *cellDef;	/* Pointer to definition of cell. */
+    CellDef *cellDef;		/* Pointer to definition of cell. */
-    char *name;		/* The name of the property desired. */
+    char *name;			/* The name of the property desired. */
-    ClientData value;	/* MUST point to a malloc'ed structure, or NULL.
+    PropertyRecord *value;	/* MUST point to a malloc'ed structure, or NULL.
-			 * This will be freed when the CellDef is freed.
+				 * This will be freed when the CellDef is freed.
-			 */
+				 */
 
 {
     HashTable *htab;
     HashEntry *entry;
-    char *oldvalue;
+    PropertyRecord *oldvalue;
 
     /* Honor the NOEDIT flag.  Note that the caller always assumes that */
     /* the value would be saved in the hash table, so if it is not	*/
@@ -95,12 +105,23 @@ DBPropPut(cellDef, name, value)
     }
 
     entry = HashFind(htab, name);
-    oldvalue = (char *)HashGetValue(entry);
+    oldvalue = (PropertyRecord *)HashGetValue(entry);
-    if (oldvalue != NULL) freeMagic(oldvalue);
+    /* All properties are allocated as a single block and can just be freed,
-    if (value == (ClientData)NULL)
+     * except for plane properties, which require freeing the plane.
+     */
+    if (oldvalue != NULL)
+    {
+	if (oldvalue->prop_type == PROPERTY_TYPE_PLANE)
+	{
+	    DBFreePaintPlane(oldvalue->prop_value.prop_plane);
+	    TiFreePlane(oldvalue->prop_value.prop_plane);
+	}
+	freeMagic((char *)oldvalue);
+    }
+    if (value == (PropertyRecord *)NULL)
 	HashRemove(htab, name);
     else
-	HashSetValue(entry, value);
+	HashSetValue(entry, PTR2CD(value));
 }
 
 /* ----------------------------------------------------------------------------
@@ -110,13 +131,13 @@ DBPropPut(cellDef, name, value)
  * Get a property from a celldef.
  *
  * Results:
- *	NULL if the property didn't exist, or if the property value was NULL.
+ *	NULL if the property didn't exist, or if the property record was NULL.
- *	Otherwise, ClientData that represents the property.
+ *	Otherwise, returns a pointer to the property record.
  *
  * ----------------------------------------------------------------------------
  */
 
-ClientData
+PropertyRecord *
 DBPropGet(cellDef, name, found)
     CellDef *cellDef;	/* Pointer to definition of cell. */
     char *name;		/* The name of the property desired. */
@@ -124,12 +145,12 @@ DBPropGet(cellDef, name, found)
 			 * exists.
 			 */
 {
-    ClientData result;
+    PropertyRecord *result;
     bool haveit;
     HashTable *htab;
     HashEntry *entry;
 
-    result = (ClientData) NULL;
+    result = (PropertyRecord *)NULL;
     haveit = FALSE;
     htab = (HashTable *) cellDef->cd_props;
     if (htab == (HashTable *) NULL) goto done;
@@ -138,7 +159,7 @@ DBPropGet(cellDef, name, found)
     if (entry != NULL)
     {
 	haveit = TRUE;
-	result = (ClientData) HashGetValue(entry);
+	result = (PropertyRecord *)HashGetValue(entry);
     }
 
 done:
@@ -146,6 +167,109 @@ done:
     return result;
 }
 
+/* ----------------------------------------------------------------------------
+ *
+ * DBPropGetString --
+ *
+ * Get a string property from a celldef.
+ *
+ * Results:
+ *	NULL if the property didn't exist, or if the property record was NULL.
+ *	Otherwise, returns a pointer to the property's string record.
+ *
+ * Notes:
+ *	This is basically the original DBPropGet(), when properties were only
+ *	allowed to be strings.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+char *
+DBPropGetString(cellDef, name, found)
+    CellDef *cellDef;	/* Pointer to definition of cell. */
+    char *name;		/* The name of the property desired. */
+    bool *found;	/* If not NULL, filled in with TRUE iff the property
+			 * exists.
+			 */
+{
+    char *result = NULL;
+    PropertyRecord *proprec;
+    bool haveit;
+    HashTable *htab;
+    HashEntry *entry;
+
+    haveit = FALSE;
+    htab = (HashTable *) cellDef->cd_props;
+    if (htab == (HashTable *) NULL) goto pdone;
+
+    entry = HashLookOnly(htab, name);
+    if (entry != NULL)
+    {
+	proprec = (PropertyRecord *)HashGetValue(entry);
+	if (proprec->prop_type == PROPERTY_TYPE_STRING)
+	{
+	    haveit = TRUE;
+	    result = proprec->prop_value.prop_string;
+	}
+    }
+
+pdone:
+    if (found != (bool *) NULL) *found = haveit;
+    return result;
+}
+
+/* ----------------------------------------------------------------------------
+ *
+ * DBPropGetDouble --
+ *
+ * Get a single double-long integer property from a celldef.
+ *
+ * Results:
+ *	NULL if the property didn't exist, or if the property record was NULL.
+ *	Otherwise, returns a pointer to the property's value record.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+dlong
+DBPropGetDouble(cellDef, name, found)
+    CellDef *cellDef;	/* Pointer to definition of cell. */
+    char *name;		/* The name of the property desired. */
+    bool *found;	/* If not NULL, filled in with TRUE iff the property
+			 * exists.
+			 */
+{
+    dlong result = 0;
+    PropertyRecord *proprec;
+    bool haveit;
+    HashTable *htab;
+    HashEntry *entry;
+
+    haveit = FALSE;
+    htab = (HashTable *) cellDef->cd_props;
+    if (htab == (HashTable *) NULL) goto ddone;
+
+    entry = HashLookOnly(htab, name);
+    if (entry != NULL)
+    {
+	proprec = (PropertyRecord *)HashGetValue(entry);
+	if (proprec->prop_type == PROPERTY_TYPE_DOUBLE)
+	{
+	    haveit = TRUE;
+	    result = proprec->prop_value.prop_double[0];
+	}
+	else if (proprec->prop_type == PROPERTY_TYPE_STRING)
+	{
+	    haveit = TRUE;
+	    sscanf(proprec->prop_value.prop_string, "%"DLONG_PREFIX"d", &result);
+	}
+    }
+
+ddone:
+    if (found != (bool *) NULL) *found = haveit;
+    return result;
+}
+
 /* ----------------------------------------------------------------------------
  *
  * DBPropEnum --
@@ -168,7 +292,7 @@ DBPropEnum(cellDef, func, cdata)
 			 *
 			 *	int foo(name, value, cdata)
 			 *	    char *name;
-			 *	    ClientData value;
+			 *	    PropertyRecord *value;
 			 *	    ClientData cdata;
 			 *	{
 			 *	    -- return 0 to continue,
@@ -189,7 +313,7 @@ DBPropEnum(cellDef, func, cdata)
     HashStartSearch(&hs);
     while ((entry = HashNext(htab, &hs)) != NULL)
     {
-	res = (*func)(entry->h_key.h_name, (ClientData) entry->h_pointer, cdata);
+	res = (*func)(entry->h_key.h_name, (PropertyRecord *)entry->h_pointer, cdata);
 	if (res != 0) return res;
     }
 

database/database.h.in

@@ -651,6 +651,7 @@ typedef struct treeFilter
 #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 */
+#define TF_LABEL_REVERSE_SEARCH 0x40	/* Search children before parent */
 
 /* To do:  Make the tpath entries dynamically allocated */
 #define FLATTERMSIZE 4096		/* Used for generating flattened labels */
@@ -704,6 +705,25 @@ struct conSrArg2
 
 #define CSA2_LIST_SIZE 65536            /* Number of entries per list */
 
+/* ------------------------  Properties  ------------------------------ */
+
+/* Note that the property record is a single allocated block large enough
+ * to hold the string or integer list, and can be freed as a single block.
+ * The array bounds, like those of lab_text for labels, are placeholders.
+ */
+
+typedef struct
+{
+    int		prop_type;	/* See codes below; e.g., PROPERTY_TYPE_STRING */
+    int		prop_len;	/* String length or number of values */
+    union {
+	char  prop_string[8];	/* For PROPERTY_TYPE_STRING */
+	int   prop_integer[2];	/* For PROPERTY_TYPE_INTEGER or _DIMENSION */
+	dlong prop_double[1];	/* For PROPERTY_TYPE_DOUBLE */
+	Plane *prop_plane;	/* For PROPERTY_TYPE_PLANE */
+    } prop_value;
+} PropertyRecord;
+
 /* -------------- Undo information passed to DBPaintPlane ------------- */
 
 typedef struct
@@ -736,6 +756,14 @@ typedef struct
 #define PAINT_MARK	1	/* Mark tiles that are painted */
 #define PAINT_XOR	2	/* Use with XOR function to prevent double-painting */
 
+/* ---------------------- Codes for properties -------------------------*/
+
+#define PROPERTY_TYPE_STRING	0	/* ASCII string property */
+#define PROPERTY_TYPE_INTEGER	1	/* Fixed integer property */
+#define PROPERTY_TYPE_DIMENSION	2	/* Integer property that scales with units */
+#define PROPERTY_TYPE_DOUBLE	3	/* Double-long integer (for file positions) */
+#define PROPERTY_TYPE_PLANE	4	/* A tile plane structure */
+
 /* -------------------- Exported procedure headers -------------------- */
 
     /* Painting/erasing */
@@ -921,7 +949,9 @@ extern void DBFreePaintPlane();
 
     /* Cell properties */
 extern void DBPropPut();
-extern ClientData DBPropGet();
+extern PropertyRecord *DBPropGet();
+extern char *DBPropGetString();
+extern dlong DBPropGetDouble();
 extern int DBPropEnum();
 extern void DBPropClearAll();
 
@@ -1019,6 +1049,7 @@ extern int DBLambda[2];
 /* -------------------- Exported magic file suffix -------------------- */
 
 extern char *DBSuffix;		/* Suffix appended to all Magic cell names */
+extern bool DBPropCompat;	/* Backwards-compatible properties */
 
 /* -------------------- User Interface Stuff -------------------------- */
 
@@ -1031,6 +1062,19 @@ extern unsigned char DBVerbose;	/* If 0, don't print any messages	*/
 #define DB_VERBOSE_WARN	2
 #define DB_VERBOSE_ALL	3
 
+/* ---------- Definitions for expanding/unexpanding cells --------------*/
+
+/* Selection expansion flags */
+#define DB_EXPAND_MASK	 	3	/* 1 = expand, 0 = unexpand, 2 = toggle */
+#define DB_EXPAND_SURROUND_MASK	4	/* 1 = surround, 0 = touch */
+
+/* Selection expansion values */
+#define DB_EXPAND      	   0
+#define DB_UNEXPAND        1
+#define DB_EXPAND_TOGGLE   2
+#define DB_EXPAND_SURROUND 4
+#define DB_EXPAND_OVERLAP  0
+
 /* ------------------ Exported technology variables ------------------- */
 
 /***

dbwind/DBWbuttons.c

@@ -131,8 +131,11 @@ DBWAddButtonHandler(
     for (i = 0; i < MAXBUTTONHANDLERS; i++)
     {
 	if (dbwButtonHandlers[i] != NULL) continue;
-	(void) StrDup(&dbwButtonHandlers[i], name);
+	StrDup(&dbwButtonHandlers[i], name);
-	(void) StrDup(&dbwButtonDoc[i], doc);
+	if (doc != NULL)
+	    StrDup(&dbwButtonDoc[i], doc);
+	else
+	    dbwButtonDoc[i] = (char *)NULL;
 	dbwButtonProcs[i] = proc;
 	dbwButtonCursors[i] = cursor;
 	return;
@@ -273,6 +276,37 @@ DBWGetButtonHandler()
     return dbwButtonHandlers[dbwButtonCurrentIndex];
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * DBWButtonHandlerIndex()
+ *
+ *	Given a string, return the index of the button handler.  If the
+ *	string does not correspond to any button handler name, then
+ *	return -1.
+ *
+ * Results:
+ *	Index of button handler, if it exists;  -1 otherwise.
+ *
+ * Side effects:
+ *	None.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+int
+DBWButtonHandlerIndex(char *toolName)
+{
+    int i;
+
+    for (i = 0; i < MAXBUTTONHANDLERS; i++)
+    {
+	if (dbwButtonHandlers[i] == NULL) return -1;
+	else if (!strcmp(toolName, dbwButtonHandlers[i])) return i;
+    }
+    return -1;
+}
+
 /*
  * ----------------------------------------------------------------------------
  *
@@ -294,7 +328,10 @@ DBWGetButtonHandler()
 void
 DBWPrintButtonDoc()
 {
-    TxPrintf("%s", dbwButtonDoc[dbwButtonCurrentIndex]);
+    if (dbwButtonDoc[dbwButtonCurrentIndex])
+	TxPrintf("%s", dbwButtonDoc[dbwButtonCurrentIndex]);
+    else
+	TxPrintf("(no usage information)\n");
 }
 
 

dbwind/DBWdisplay.c

@@ -421,7 +421,8 @@ DBWredisplay(w, rootArea, clipArea)
         /* Set style information beforehand */
         GrSetStuff(STYLE_LABEL);
 	(void) DBTreeSrLabels(&scontext, &DBAllTypeBits, bitMask,
-		(TerminalPath *) NULL, TF_LABEL_DISPLAY | TF_LABEL_ATTACH,
+		(TerminalPath *) NULL,
+		TF_LABEL_DISPLAY | TF_LABEL_ATTACH | TF_LABEL_REVERSE_SEARCH,
 		dbwLabelFunc, (ClientData)(&crec->dbw_visibleLayers));
 	GrClipTo(&rootClip);
     }

dbwind/DBWprocs.c

@@ -546,12 +546,12 @@ DBWloadWindow(window, name, flags)
 	newEditUse = DBCellNewUse(newEditDef, (char *) NULL);
 	(void) StrDup(&(newEditUse->cu_id), "Topmost cell in the window");
 	DBExpand(newEditUse,
-		((DBWclientRec *)window->w_clientData)->dbw_bitmask, TRUE);
+		((DBWclientRec *)window->w_clientData)->dbw_bitmask, DB_EXPAND);
 
 	if (expand)
 	    DBExpandAll(newEditUse, &(newEditUse->cu_bbox),
 			((DBWclientRec *)window->w_clientData)->dbw_bitmask,
-			FALSE, UnexpandFunc,
+			DB_UNEXPAND, UnexpandFunc,
 			INT2CD(((DBWclientRec *)window->w_clientData)->dbw_bitmask));
 
 	if (newEdit)

dbwind/dbwind.h

@@ -152,6 +152,7 @@ extern void DBWAddButtonHandler(const char *name, const cb_database_buttonhandle
                                 int cursor, const char *doc);
 extern char *DBWGetButtonHandler();
 extern char *DBWChangeButtonHandler();
+extern int  DBWButtonHandlerIndex();
 extern void DBWPrintButtonDoc();
 extern void DBWBoxHandler();
 

doc/html/cellname.html

@@ -71,12 +71,15 @@ Operations on cell definitions.
 	   <DT> <B>rename</B> <I>name newname</I>
 	   <DD> Change the name of the cell definition <I>name</I> to 
 		<I>newname</I>.
-	   <DT> <B>delete</B> <I>name</I>
+	   <DT> <B>delete</B> <I>name</I> [<B>-noprompt</B>]
 	   <DD> Delete the cell definition with name <I>name</I>.  If cell
 		<I>name</I> is a descendent of another cell, the command
 		will be prohibited.  If the cell <I>name</I> is currently
 		the topmost cell in the window, the window will be loaded
-		with default cell "(UNNAMED)".
+		with default cell "(UNNAMED)".  If option <B>-noprompt</B>
+		is specified, then the actions specified above happen
+		immediately.  Otherwise, a dialog box will be raised
+		asking for confirmation to delete the cell.
 	   <DT> <B>dereference</B> <I>name</I>
 	   <DD> Perform a flush of the cell (per the "<B>flush</B>" command),
 		first removing any file path associated with the cell, so

doc/html/expand.html

@@ -26,7 +26,8 @@ expanded/unexpanded cells in the current selection.
 
 <H3>Usage:</H3>
    <BLOCKQUOTE>
-      <B>expand</B> [<B>toggle</B>] <BR><BR>
+      <B>expand</B> [<B>selection</B>|<B>surround</B>|<B>overlap</B>|<B>all</B>]
+		[<B>toggle</B>] <BR><BR>
    </BLOCKQUOTE>
 
 <H3>Shortcuts:</H3>
@@ -38,14 +39,32 @@ expanded/unexpanded cells in the current selection.
 <H3>Summary:</H3>
    <BLOCKQUOTE>
       The <B>expand</B> command expands the view of subcells to
-      display the contents of the subcells.  Without arguments,
+      display the contents of the subcells.
-      the <B>expand</B> command expands all unexpanded subcells that
+
-      touch or intersect the cursor box in the layout window. <P>
+      Option <B>overlap</B> expands all unexpanded subcells that
+      overlap with the cursor box in the layout window. <P>
+
+      Option <B>surround</B> expands all unexpanded subcells that
+      are completely surrounded by the cursor box in the layout window. <P>
+
+      Option <B>all</B> expands all subcells in the layout window. <P>
+
+      Option <B>selection</B> operates on the current selection, not
+      relative to the cursor box, expanding all selected cells. <P>
+
+      Option <B>toggle</B> will expand a selected cell that is
+      unexpanded, or unexpand a cell that is already expanded.
+      <B>toggle</B> may be given as an additional option to any
+      of the other options above; however, the <B>toggle</B> option
+      must be the last option given to the command.<P>
+
+      With no arguments, the <B>expand</B> command behaves like
+      <B>expand overlap</B>, and the <B>expand toggle</B> command
+      with no additonal arguments behaves like
+      <B>expand selection toggle</B>, for backwards-compatible
+      behavior with earlier versions of magic which offered only
+      the <B>toggle</B> option.
 
-      Option <B>expand toggle</B> operates on the current selection,
-      not relative to the cursor box, and will expand a selected
-      cell that is unexpanded, or unexpand a cell that is already
-      expanded.
    </BLOCKQUOTE>
 
 <H3>Implementation Notes:</H3>

doc/html/gds.html

@@ -182,6 +182,13 @@ Read GDSII input or generate GDSII output.
 		 than to subsplit the internal grid to such a fine value.
 		 The "<B>cif limit</B>" function may also be used to limit
 		 grid subdivision to a minimum value.
+	    <DT> <B>savepaths</B> [<B>yes</B>|<B>no</B>]
+	    <DD> When reading paths from a GDS file, record the centerline of
+		 the path as a property in the cell.  The default behavior is
+		 <B>no</B>.  If no argument is given, then return the status
+		 of the <B>savepaths</B> option.  The first path property is
+		 named "<TT>path</TT>", followed by "<TT>path_0</TT>" and
+		 increasing the suffix index for each individual path read.
 	    <DT> <B>unique</B> [<B>yes</B>|<B>no</B>]
 	    <DD> When reading a GDS file, this option forces magic to rename
 		 cell definitions in the database when a cell of the same name

doc/html/label.html

@@ -87,6 +87,50 @@ Place a label in the layout
       to another layer. <P>
    </BLOCKQUOTE>
 
+   <BLOCKQUOTE>
+      <B>Attribute labels:</B> <P>
+      A handful of labels are referred to as "attribute" labels.  These
+      label types are placed on devices and affect how the device is
+      extracted. <P>
+
+      A label that is placed inside a device (e.g., a MOSFET gate) which
+      ends with the character "<B>^</B>" is a <I>gate attribute</I>.  A
+      gate attribute in the form of "<I>name</I><B>=</B><I>value</I><B>^</B>"
+      specifies an extra parameter to be passed to the device in addition
+      to the standard parameters calculated for that device.  This is used
+      to capture parameters which cannot easily be inferred from the layout.
+      For example, an RF device model might be distinguished from a non-RF
+      device model by a parameter such as <B>rfmode=1</B>.  Whether or not
+      a device is intended for RF use is not easily guessed from the layout,
+      and so "tagging" the gate with the parameter allows the correct model
+      parameters to be used for the device. <P>
+
+      A gate attribute that is not in the form of a parameter will be used
+      as the device's instance index in the netlist;  e.g.,  a label of
+      "<B>1^</B>" on a MOSFET gate extracted as a MOSFET device would be an
+      entry "<B>M1</B>" in the netlist.  This can be used to better track
+      device indexes between a schematic and layout. <P>
+
+      A label that is placed on the <I>edge</I> a device, specificlly  a
+      MOSFET gate, and which ends with the character "<B>$</B>", is a
+      <I>terminal attribute</I>.  The only terminal attributes recognized
+      by magic are <B>S$</B> and <B>D$</B>, which specify which side of the
+      gate is to be considered the source and which is to be considered the
+      drain.  Generally, MOSFET devices are symmetric, and their use in a
+      simulation does not depend on which side is in the position of the
+      "source" and which is in the position of the "drain".  To the extent
+      that it matters, the terminal attributes can be used to ensure that
+      the source and drain connections appear in the netlist in their
+      intended orientation. <P>
+
+      Labels ending with "<B>@</B>" are <I>node attributes</I>.  There is
+      currently no functional application for node attributes.  When one
+      is applied, it will appear in the output netlist in a SPICE comment
+      line indicating the node and attribute.  This could be used, say,
+      by a post-processing script, but as it is in a comment line, it has
+      no impact on simulation or LVS.
+   </BLOCKQUOTE>
+
 <H3>Implementation Notes:</H3>
    <BLOCKQUOTE>
       <B>label</B> is implemented as a built-in command in <B>magic</B>.

doc/html/macro.html

@@ -20,22 +20,64 @@
 
 <H2>macro</H2>
 <HR>
-Define or print a macro called char
+Define or print a key or button macro binding.
 <HR>
 
 <H3>Usage:</H3>
    <BLOCKQUOTE>
-      <B>macro</B> [<I>window_type</I>] [<I>key</I> [<I>value</I>]] <BR><BR>
+      <B>macro</B> [<I>window_type</I>] [<I>option</I>] [<I>key</I> [<I>value</I>]]
+		<BR><BR>
       <BLOCKQUOTE>
 	 where <I>key</I> is the name of a valid key (see below), and
 	 <I>value</I> is a <B>magic</B> command-line command.  If
-	 present, <I>window_type</I> must be one of the four window
+	 present, <I>window_type</I> must be one of the known valid window
-	 types accepted by the <B>specialopen</B> command:  <B>layout</B>,
+	 types accepted by the <B>specialopen</B> command (<B>color</B>,
-	 <B>color</B>, <B>netlist</B>, and <B>wind3d</B>.  If omitted,
+	 <B>netlist</B>, and <B>wind3d</B>), or a known layout tool
-	 the layout window is assumed by default, unless the command has
+	 (<B>box</B>, <B>wiring</B>, <B>nettool</B>, or <B>pick</B>).  If
-	 been called from inside a window (using the colon or semicolon
+	 omitted, the layout window is assumed by default, unless the command
+	 has been called from inside a window (using the colon or semicolon
 	 escape to the command-line), in which case that window type is
-	 assumed.
+	 assumed. <P>
+
+	 In the non-Tcl version of magic, the <I>window_type</I> must be
+	 one of the three valid window types listed above, or <B>layout</B>.
+	 Tool button bindings are hard-coded, fixed, and unknown to the
+	 macro handler. <P>
+
+	 In the Tcl version of magic, tool types are generated by
+	 procedure and can be modified or overridden.  The four tools
+	 listed above are the default tools known to magic.  If no window
+	 or tool type is given, then the current tool in the current
+	 active layout window is assumed.<P>
+
+	 <I>option</I> may be one of the following:
+	 <DL>
+	    <DT> <B>list</B> [<B>-reverse</B>]
+	    <DD> The key bindings are returned in the form of a Tcl list
+		(Tcl version of magic only).  The returned value is a
+		single list with alternating entries of the macro key and
+		the macro binding.  In Tcl, this list can be treated as a
+		dictionary type of key:value pairs.  With the <B>-reverse</B>
+		option, the keys and values are reversed, resulting in a
+		dictionary that can be searched or listed by function.
+	    <DT> <B>help</B>
+	    <DD> Curently, <B>macro help</B> is equivalent to <B>macro</B>
+		 without arguments, and returns a full list of macro names
+		 and their bindings.
+	    <DT> <B>search</B> <I>text</I>
+	    <DD> Return only results which match (all or in part) the string
+		 <I>text</I>.  For example, <B>macro search grid</B> will
+		 return all key bindings that include the command <B>grid</B>.
+	    <DT> <B>copy</B> <I>tool_name</I>
+	    <DD> This is a method introduced to allow the interactive creation
+		 of new tools, in the Tcl version of magic.  Each tool is defined
+		 specifically by its unique button and key bindings.  Because
+		 tools generally keep most of the same default bindings, the
+		 <B>copy</B> option will copy all the existing bindings to the
+		 new tool from the current tool.  This can be followed by
+		 switching to the new tool and replacing macros with ones
+		 unique to the tool.
+	 </DL>
       </BLOCKQUOTE>
    </BLOCKQUOTE>
 
@@ -72,7 +114,6 @@ Define or print a macro called char
       etc., the <B>macro</B> command accepts the abbreviated
       forms <B>Button1</B>, and so forth. <P>
 
-
       Finally, key modifiers may be prepended to the key name.
       Valid key modifiers are <B>Shift_</B>, <B>Control_</B>,
       <B>Alt_</B>, and <B>Meta_</B>, and may be coupled in any
@@ -89,6 +130,7 @@ Define or print a macro called char
 <H3>See Also:</H3>
    <BLOCKQUOTE>
       <A HREF=imacro.html><B>imacro</B></A> <BR>
+      <A HREF=toolchange.html><B>tool</B></A> (Tcl version) <BR>
    </BLOCKQUOTE>
 
 <P><IMG SRC=graphics/line1.gif><P>

doc/html/property.html

@@ -25,9 +25,13 @@ Attach a "property" (string key and value pair) to the edit cell
 
 <H3>Usage:</H3>
    <BLOCKQUOTE>
-      <B>property</B> [<I>key</I> [<I>value</I>]] <BR><BR>
+      <B>property</B> [<I>list</I>] [<I>type</I>] [<I>key</I> [<I>value</I>]] <BR>
+	or
+      <B>property</B> [<B>compat</B>] [<B>true</B>|<B>false</B>] <BR><BR>
       <BLOCKQUOTE>
-         where <I>key</I> and <I>value</I> are any text strings.
+         where <I>key</I> and <I>value</I> are any text strings. <BR>
+	 <I>type</I> may be one of <B>string</B>, <B>integer</B>,
+		<B>dimension</B>, or <B>double</B>.
       </BLOCKQUOTE>
    </BLOCKQUOTE>
 
@@ -45,11 +49,64 @@ Attach a "property" (string key and value pair) to the edit cell
       with the key is returned.  With both arguments, the string
       <I>value</I> is associated with the string <I>key</I> as a
       property of the cell.  If <I>key</I> is an existing key, then
-      its original value will be overwritten.
+      its original value will be overwritten.  <P>
+
+      By default, properties are interpreted as verbatim string values,
+      with exceptions for the reserved types (see below).  To force the
+      values of the property to be interpreted as a specific type, use
+      the <I>type</I> option. <P>
+
+      The <B>property compat</B> setting determines how properties are
+      written out to a .mag file.  The default setting is <B>true</B>
+      (backwards compatibility mode), which writes all properties as
+      type "<TT>string</TT>".  Properties which are reserved names
+      (see below) will be converted to the best type when reading the
+      .mag file.  However, if the user wants to create a property that
+      is handled differently than a string (namely, to be a dimensional
+      value that scales), then comptability mode should be turned off. <P>
+
+      If the argument <I>list</I> is given as the first argument, and
+      <I>value</I> is not present, then if the property <I>key</I>
+      does not exist, then the command will return a NULL object to the
+      interpreter instead of printing an error message.  This is the
+      "quiet" version of the command preferred for scripts that want to
+      query whether or not a specific property exists.
    </BLOCKQUOTE>
 
    <BLOCKQUOTE>
-      Property names reserved by and used by magic:
+      Types are interpreted as follows:
+      <DL>
+	<DT> <B>string</B> type:
+	<DD> The property value is a character string.  Character strings
+	     may contain spaces, but if so, then the string should be quoted
+	     or in braces, per Tcl syntax.
+	<DT> <B>integer</I> type:
+	<DD> The property value is an integer value or a list of integer
+	     values.  The values are not considered to be measurements and
+	     do not scale.  Multiple values may be passed on the command
+	     line as additional arguments, or the set of values may be
+	     given as a list.
+	<DT> <B>dimension</I> type:
+	<DD> The property value is an integer value or a list of integer
+	     values.  The values are considered to be (linear) dimensional
+	     measurements and therefore scale with the database internal
+	     units.  They are interpreted as having the values currently
+	     specified for <B>units</B>, and display back in the same
+	     units.  Multiple values may be passed on the command line as
+	     additional arguments, or the set of values may be given as a
+	     list.
+	<DT> <B>double</I> type:
+	<DD> The property value is a double-wide (64-bit) integer value or
+	     a list of double-wide integer values.  The values are not
+	     considered to be measurements and do not scale.  Multiple
+	     values may be passed on the command line as additional arguments,
+	     or the set of values may be given as a list.
+      </DL>
+   </BLOCKQUOTE>
+
+   <BLOCKQUOTE>
+      Property names reserved by and used by magic (types are <B>string</B>
+      unless otherwise noted):
       <DL>
 	<DT> <B>GDS_FILE</B>
 	<DD> The value is the name of a GDS file which contains the mask
@@ -60,12 +117,14 @@ Attach a "property" (string key and value pair) to the edit cell
 	<DD> If a <B>GDS_FILE</B> is defined, then this value indicates the
 	     byte position of the start of mask data for this cell definition
 	     in the file.  If set to value <B>0</B>, then the file will be
-	     searched for the data bounds.
+	     searched for the data bounds.  This property is always of type
+	     <B>double</B>.
 	<DT> <B>GDS_END</B>
 	<DD> If a <B>GDS_FILE</B> is defined, then this value indicates the
 	     byte position of the end of mask data for this cell definition
 	     in the file.  If <B>GDS_START</B> is set to <B>0</B>, then this
-	     property may be omitted.
+	     property may be omitted.  This property is always of type
+	     <B>double</B>.
 	<DT> <B>LEFview</B>
 	<DD> If set to <B>TRUE</B>, this cell is an abstract view such as that
 	     obtained from a LEF macro, and should not be used for extraction
@@ -97,6 +156,8 @@ Attach a "property" (string key and value pair) to the edit cell
 	     corresponding to the abutment box of the cell, in magic's internal
 	     units.  The abutment box is automatically read from LEF files, but
 	     may be defined for any file and can be used for placement alignment.
+	     This property is always of type <B>dimension</B> and must contain
+	     exactly four values.
 	<DT> <B>OBS_BBOX</B>
 	<DD> This property value is a space-sparated list of four integer values
 	     corresponding to a bounding box to be used when generating a LEF
@@ -104,7 +165,8 @@ Attach a "property" (string key and value pair) to the edit cell
 	     will be entirely covered in obstruction layers (unless cut-outs
 	     are required to accommodate pins).  Any set-back applied by the
 	     "lef write -hide <value>" option will be applied to this obstruction
-	     box.
+	     box.  This property is always of type <B>dimension</B> and must
+	     contain exactly four values.
 	<DT> <B>flatten</B>
 	<DD> This property is used in conjunction with the "flatten -doproperty"
 	     command option and marks the cell for flattening.  Cells without
@@ -146,7 +208,8 @@ Attach a "property" (string key and value pair) to the edit cell
 	     always generate mask layer <I>type</I> in the specified rectangle
 	     area when writing GDS or CIF output.  <I>type</I> may be a templayer,
 	     such that <I>type</I> could be defined as the absence of a mask layer,
-	     for example.
+	     for example.  This property is always of type <B>dimension</B> and
+	     must have a multiple of four values.
       </DL>
    </BLOCKQUOTE>
 
@@ -157,6 +220,11 @@ Attach a "property" (string key and value pair) to the edit cell
       the cell definition structure.
    </BLOCKQUOTE>
 
+<H3>See Also:</H3>
+   <BLOCKQUOTE>
+      <A HREF=units.html><B>units</B></A> <BR>
+   </BLOCKQUOTE>
+
 <P><IMG SRC=graphics/line1.gif><P>
 <TABLE BORDER=0>
   <TR>

doc/html/unexpand.html

@@ -25,7 +25,8 @@ Unexpand everything inside or touching the cursor box.
 
 <H3>Usage:</H3>
    <BLOCKQUOTE>
-      <B>unexpand</B> <BR><BR>
+      <B>unexpand</B> [<B>selection</B>|<B>surround</B>|<B>overlap</B>|<B>all</B>]
+		<BR><BR>
    </BLOCKQUOTE>
 
 <H3>Shortcuts:</H3>
@@ -37,8 +38,23 @@ Unexpand everything inside or touching the cursor box.
    <BLOCKQUOTE>
       The <B>unexpand</B> command unexpands the view of subcells to
       hide the contents of the subcells and show the bounding box
-      outline only.  The <B>unexpand</B> command unexpands all subcells
+      outline only.
-      that touch or intersect the cursor box in the layout window. <P>
+
+      Option <B>overlap</B> unexpands all expanded subcells that
+      overlap with the cursor box in the layout window. <P>
+
+      Option <B>surround</B> unexpands all expanded subcells that
+      are completely surrounded by the cursor box in the layout window. <P>
+
+      Option <B>all</B> unexpands all subcells in the layout window. <P>
+
+      Option <B>selection</B> operates on the current selection, not
+      relative to the cursor box, unexpanding all selected cells. <P>
+
+      With no arguments, the <B>unexpand</B> command behaves like
+      <B>unexpand surround</B>, for backwards-compatible behavior with
+      earlier versions of magic which did not offer the options.
+
    </BLOCKQUOTE>
 
 <H3>Implementation Notes:</H3>

doc/html/view.html

@@ -45,10 +45,12 @@ view [get|bbox|llx lly urx ury]
       center and scale the screen view of the layout window to fit the layout. <P>
 
       <B>view bbox</B> returns the bounding box dimensions of the layout,
-      in the coordinate system of the layout. <P>
+      in the coordinate system of the layout (according to the units
+      set by the "units" command). <P>
 
       <B>view get</B> returns the coordinates of the screen limits in
-      the coordinate system of the layout (internal database units). <P>
+      the coordinate system of the layout (according to the units set
+      by the "units" command). <P>
 
       <B>view</B> <I>llx lly urx ury</I> sets the view so that the
       corners of the screen are at the indicated positions in the

drc/DRCarray.c

@@ -45,7 +45,7 @@ extern int drcArrayYankFunc(), drcArrayOverlapFunc();
 static DRCCookie drcArrayCookie = {
     0, 0, 0, 0,
     { {0} }, { {0} },
-    0, 0, 0,
+    0, DRC_EXCEPTION_NONE, 0, 0,
     DRC_ARRAY_OVERLAP_TAG,
     (DRCCookie *) NULL
 };

drc/DRCbasic.c

@@ -27,6 +27,8 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include <stdio.h>
 #include <string.h>		// for memcpy()
 #include <math.h>		// for sqrt() for diagonal check
+
+#include "tcltk/tclmagic.h"
 #include "utils/magic.h"
 #include "utils/geometry.h"
 #include "tiles/tile.h"
@@ -36,7 +38,9 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include "utils/signals.h"
 #include "utils/maxrect.h"
 #include "utils/malloc.h"
+#include "utils/undo.h"
 #include "textio/textio.h"
+#include "cif/CIFint.h"
 
 int dbDRCDebug = 0;
 
@@ -48,7 +52,7 @@ int dbDRCDebug = 0;
 static DRCCookie drcOverlapCookie = {
     0, 0, 0, 0,
     { {0} }, { {0} },
-    0, 0, 0,
+    0, DRC_EXCEPTION_NONE, 0, 0,
     DRC_OVERLAP_TAG,
     (DRCCookie *) NULL
 };
@@ -62,7 +66,33 @@ extern MaxRectsData *drcCanonicalMaxwidth();
 /*
  *-----------------------------------------------------------------------
  *
- * drcCifPointToSegment
+ * drcFoundOneFunc --
+ *
+ *	Simple callback for a plane search on a mask-hint plane inside
+ *	a DRC check area.
+ *
+ * Results:
+ *	Return 1 always, indicating that a tile has been found in the
+ *	DRC search area, and the search can end.
+ *
+ * Side effects:
+ *	None.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+int
+drcFoundOneFunc(Tile *tile,
+    TileType dinfo,
+    ClientData cdata)
+{
+    return 1;
+}
+
+/*
+ *-----------------------------------------------------------------------
+ *
+ * drcCifPointToSegment --
  *
  *	Euclidean-distance point-to-segment distance (squared)
  *	calculation (borrowed from XCircuit)
@@ -468,6 +498,26 @@ DRCBasicCheck (celldef, checkRect, clipRect, function, cdata)
 	DBResetTilePlane(celldef->cd_planes[planeNum], DRC_UNPROCESSED);
         (void) DBSrPaintArea ((Tile *) NULL, celldef->cd_planes[planeNum],
 		checkRect, &DBAllTypeBits, drcTile, (ClientData) &arg);
+
+#ifdef MAGIC_WRAPPER
+	/* Execute pending Tcl events, so the DRC process doesn't block.    */
+
+	/* WARNING:  This code cannot be enabled until some method is
+	 * worked out to determine if any event resulted in a change
+	 * to the DRC check plane which would invalidate the current
+	 * search.  If so, the search must end immediately and the
+	 * area being checked must be reinstated.  The code was added
+	 * to see how it speeds up the response time of magic when
+	 * some of the DRC rules are compute-intensive.  It speeds up
+	 * performance enough that it is worthwhile to implement the
+	 * method just mentioned.
+	 */
+	#if 0
+	UndoEnable();
+	while (Tcl_DoOneEvent(TCL_DONT_WAIT));
+	UndoDisable();
+	#endif
+#endif
     }
     drcCifCheck(&arg);
     if (arg.dCD_rlist != NULL) freeMagic(arg.dCD_rlist);
@@ -727,6 +777,44 @@ drcTile (tile, dinfo, arg)
 	    for (cptr = DRCCurStyle->DRCRulesTbl[to][tt]; cptr != (DRCCookie *) NULL;
 			cptr = cptr->drcc_next)
 	    {
+		/* Handle rule exceptions and exemptions */
+		if (cptr->drcc_exception != DRC_EXCEPTION_NONE)
+		{
+		    PropertyRecord *proprec;
+		    bool propfound, isinside = FALSE;
+		    char *name;
+		    int idx = cptr->drcc_exception & ~DRC_EXCEPTION_MASK;
+		    name = DRCCurStyle->DRCExceptionList[idx];
+
+		    /* Is there any exception area defined? */
+		    proprec = DBPropGet(arg->dCD_celldef, name, &propfound);
+
+		    /* If an exception area exists, is the error edge inside? */
+		    if (propfound)
+		    {
+			Rect redge;
+
+			redge.r_xbot = redge.r_xtop = edgeX;
+			redge.r_ybot = edgeBot;
+			redge.r_ytop = edgeTop;
+
+			if (DBSrPaintArea(PlaneGetHint(proprec->prop_value.prop_plane),
+				proprec->prop_value.prop_plane,
+				&redge, &CIFSolidBits, drcFoundOneFunc,
+				(ClientData)NULL) == 1)
+			    isinside = TRUE;
+		    }
+
+		    /* Exemption rules are ignored if the edge is inside
+		     * an exception area.  Exception rules are ignored if
+		     * the edge is outside an exception area.
+		     */
+		    if (!isinside && (!(cptr->drcc_exception & DRC_EXCEPTION_MASK) == 0))
+			continue;
+		    if (isinside && ((cptr->drcc_exception & DRC_EXCEPTION_MASK) != 0))
+			continue;
+		}
+
 	    	/* DRC_ANGLES_90 and DRC_SPLITTILE rules are handled by	*/
 		/* the code above for non-Manhattan shapes and do not	*/
 		/* need to be processed again.				*/
@@ -1136,6 +1224,44 @@ drcTile (tile, dinfo, arg)
 	    for (cptr = DRCCurStyle->DRCRulesTbl[to][tt]; cptr != (DRCCookie *) NULL;
 				cptr = cptr->drcc_next)
 	    {
+		/* Handle rule exceptions and exemptions */
+		if (cptr->drcc_exception != DRC_EXCEPTION_NONE)
+		{
+		    PropertyRecord *proprec;
+		    bool propfound, isinside = FALSE;
+		    char *name;
+		    int idx = cptr->drcc_exception & ~DRC_EXCEPTION_MASK;
+		    name = DRCCurStyle->DRCExceptionList[idx];
+
+		    /* Is there any exception area defined? */
+		    proprec = DBPropGet(arg->dCD_celldef, name, &propfound);
+
+		    /* If an exception area exists, is the error edge inside? */
+		    if (propfound)
+		    {
+			Rect redge;
+
+			redge.r_ybot = redge.r_ytop = edgeY;
+			redge.r_xbot = edgeLeft;
+			redge.r_xtop = edgeRight;
+
+			if (DBSrPaintArea(PlaneGetHint(proprec->prop_value.prop_plane),
+				proprec->prop_value.prop_plane,
+				&redge, &CIFSolidBits, drcFoundOneFunc,
+				(ClientData)NULL) == 1)
+			    isinside = TRUE;
+		    }
+
+		    /* Exemption rules are ignored if the edge is inside
+		     * an exception area.  Exception rules are ignored if
+		     * the edge is outside an exception area.
+		     */
+		    if (!isinside && ((cptr->drcc_exception & DRC_EXCEPTION_MASK) == 0))
+			continue;
+		    if (isinside && ((cptr->drcc_exception & DRC_EXCEPTION_MASK) != 0))
+			continue;
+		}
+
 	    	/* DRC_ANGLES_90 and DRC_SPLITTILE rules are handled by	*/
 		/* the code above for non-Manhattan shapes and do not	*/
 		/* need to be processed again.				*/

drc/DRCsubcell.c

@@ -52,7 +52,7 @@ static ClientData drcSubClientData; /* To be passed to error function. */
 static DRCCookie drcSubcellCookie = {
     0, 0, 0, 0,
     { {0} }, { {0} },
-    0, 0, 0,
+    0, DRC_EXCEPTION_NONE, 0, 0,
     DRC_SUBCELL_OVERLAP_TAG,
     (DRCCookie *) NULL
 };
@@ -65,7 +65,7 @@ static DRCCookie drcSubcellCookie = {
 static DRCCookie drcInSubCookie = {
     0, 0, 0, 0,
     { {0} }, { {0} },
-    0, 0, 0,
+    0, DRC_EXCEPTION_NONE, 0, 0,
     DRC_IN_SUBCELL_TAG,
     (DRCCookie *) NULL
 };
@@ -79,7 +79,7 @@ static DRCCookie drcInSubCookie = {
 static DRCCookie drcOffGridCookie = {
     0, 0, 0, 0,
     { {0} }, { {0} },
-    0, 0, 0,
+    0, DRC_EXCEPTION_NONE, 0, 0,
     DRC_OFFGRID_TAG,
     (DRCCookie *) NULL
 };
@@ -826,6 +826,7 @@ DRCInteractionCheck(def, area, erasebox, func, cdarg)
 		 */
 		subArea = *erasebox;
 		GeoClip(&subArea, &cliparea);
+		if (GEO_RECTNULL(&subArea)) continue;
 		GEO_EXPAND(&subArea, DRCTechHalo, &intArea);
 
 		errorSaveType = DRCErrorType;

drc/DRCtech.c

@@ -72,6 +72,12 @@ static int drcRulesOptimized = 0;
 
 static int DRCtag = 0;
 
+/* Keep track of what rule exemption or exception is in effect
+ * while reading the DRC tech file section.
+ */
+
+static unsigned char drcCurException = DRC_EXCEPTION_NONE;
+
 /*
  * Forward declarations.
  */
@@ -79,6 +85,7 @@ int drcWidth(), drcSpacing(), drcEdge(), drcNoOverlap();
 int drcExactOverlap(), drcExtend();
 int drcSurround(), drcRectOnly(), drcOverhang();
 int drcStepSize(), drcOption(), drcOffGrid();
+int drcException(), drcExemption();
 int drcMaxwidth(), drcArea(), drcRectangle(), drcAngles();
 int drcCifSetStyle(), drcCifWidth(), drcCifSpacing();
 int drcCifMaxwidth(), drcCifArea();
@@ -301,6 +308,12 @@ drcTechFreeStyle()
 	/* Clear the Why string list */
 	freeMagic(DRCCurStyle->DRCWhyList);
 
+	/* Clear the exception list */
+	for (i = 0; i < DRCCurStyle->DRCExceptionSize; i++)
+	    freeMagic(DRCCurStyle->DRCExceptionList[i]);
+	if (DRCCurStyle->DRCExceptionList != (char **)NULL)
+	    freeMagic(DRCCurStyle->DRCExceptionList);
+
 	freeMagic(DRCCurStyle);
 	DRCCurStyle = NULL;
     }
@@ -384,6 +397,63 @@ drcWhyCreate(whystring)
     return DRCCurStyle->DRCWhySize;
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ * drcExceptionCreate --
+ *
+ * Create an entry for a DRC rule exception/exemption type, if it does
+ * not already exist.
+ *
+ * Results:
+ *	The index of the exception (which is an unsigned character containing
+ *	the index in the lower 7 bits and a high bit indicating if the rule
+ *	is an exception (0) or an exemption (1)).
+ *
+ * Side effects:
+ *	Adds to the DRCExceptionList if "name" has not been used before.
+ *	Calls StrDup() and increments DRCExceptionSize.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+unsigned char
+drcExceptionCreate(name)
+    char *name;
+{
+    int i;
+    char **newlist;
+
+    /* NOTE:  DRCExceptionList has "MASKHINTS_" prepended to the names */
+    for (i = 0; i < DRCCurStyle->DRCExceptionSize; i++)
+	if (!strcmp(name, DRCCurStyle->DRCExceptionList[i] + 10))
+	    return (unsigned char)i;
+
+    /* Note that i cannot be 127 as this is reserved for DRC_EXCEPTION_NONE */
+    if (i > 126)
+    {
+	/* I would be shocked if this code ever got executed. */
+	TxError("Error:  Too many rule exceptions!  Limit is 126.\n");
+	return DRC_EXCEPTION_NONE;
+    }
+
+    /* Create a new list that is one entry longer than the old list.
+     * This is not elegant but there will never be more than a handful
+     * of exceptions in a rule deck.
+     */
+    newlist = (char **)mallocMagic((i + 1) * sizeof(char *));
+    for (i = 0; i < DRCCurStyle->DRCExceptionSize; i++)
+	newlist[i] = DRCCurStyle->DRCExceptionList[i];
+
+    /* The rule deck does not have the "MASKHINTS_" prefix on the name */
+    newlist[i] = (char *)mallocMagic(strlen(name) + 11);
+    sprintf(newlist[i], "MASKHINTS_%s", name);
+    DRCCurStyle->DRCExceptionSize++;
+    if (DRCCurStyle->DRCExceptionList != (char **)NULL)
+	freeMagic(DRCCurStyle->DRCExceptionList);
+    DRCCurStyle->DRCExceptionList = newlist;
+    return (unsigned char)i;
+}
+    
 /*
  * ----------------------------------------------------------------------------
  *
@@ -571,6 +641,8 @@ DRCTechStyleInit()
     DRCCurStyle->DRCStepSize = 0;
     DRCCurStyle->DRCFlags = (char)0;
     DRCCurStyle->DRCWhySize = 0;
+    DRCCurStyle->DRCExceptionList = (char **)NULL;
+    DRCCurStyle->DRCExceptionSize = 0;
 
     HashInit(&DRCWhyErrorTable, 16, HT_STRINGKEYS);
 
@@ -663,6 +735,7 @@ DRCTechStyleInit()
 	    }
 
     drcCifInit();
+    drcCurException = DRC_EXCEPTION_NONE;
 }
 
 /*
@@ -955,6 +1028,7 @@ drcCifAssign(cookie, dist, next, mask, corner, tag, cdist, flags, planeto, plane
     (cookie)->drcc_plane = planeto;
     (cookie)->drcc_mod = 0;
     (cookie)->drcc_cmod = 0;
+    (cookie)->drcc_exception = drcCurException;
 }
 
 // This is like drcCifAssign, but checks for bad plane numbers in planeto and
@@ -1031,50 +1105,37 @@ DRCTechAddRule(sectionName, argc, argv)
 	int    (*rk_proc)();	/* Procedure implementing this keyword */
 	const char *rk_err;	/* Error message */
     } ruleKeys[] = {
-	{"angles",	 4,	4,	drcAngles,
+	{"angles",	 4,	4,	drcAngles, "layers 45|90 why"},
-    "layers 45|90 why"},
 	{"edge",	 8,	10,	drcEdge,
     "layers1 layers2 distance okTypes cornerTypes cornerDistance [option] why [plane]"},
 	{"edge4way",	 8,	10,	drcEdge,
     "layers1 layers2 distance okTypes cornerTypes cornerDistance [option] why [plane]"},
-	{"exact_overlap", 2,	2,	drcExactOverlap,
+	{"exact_overlap", 2,	2,	drcExactOverlap, "layers"},
-    "layers"},
+	{"exception",	 2,	2,	drcException, "name"},
+	{"exemption",	 2,	2,	drcExemption, "name"},
 	{"extend",	 5,	6,	drcExtend,
     "layers1 layers2 distance [option] why"},
-	{"no_overlap",	 3,	3,	drcNoOverlap,
+	{"no_overlap",	 3,	3,	drcNoOverlap, "layers1 layers2"},
-    "layers1 layers2"},
+	{"option",	 2,	2,	drcOption, "option_name option_value"},
-	{"option",	 2,	2,	drcOption,
+	{"overhang",	 5,	5,	drcOverhang, "layers1 layers2 distance why"},
-    "option_name option_value"},
+	{"rect_only",	 3,	3,	drcRectOnly, "layers why"},
-	{"overhang",	 5,	5,	drcOverhang,
-    "layers1 layers2 distance why"},
-	{"rect_only",	 3,	3,	drcRectOnly,
-    "layers why"},
 	{"spacing",	 6,	7,	drcSpacing,
     "layers1 layers2 separation [layers3] adjacency why"},
-	{"stepsize",	 2,	2,	drcStepSize,
+	{"stepsize",	 2,	2,	drcStepSize, "step_size"},
-    "step_size"},
 	{"surround",	 6,	7,	drcSurround,
     "layers1 layers2 distance presence why"},
-	{"width",	 4,	5,	drcWidth,
+	{"width",	 4,	5,	drcWidth, "layers width why"},
-    "layers width why"},
 	{"widespacing",	 7,	8,	drcSpacing,
     "layers1 width layers2 separation adjacency why"},
-        {"area",	 5,	5,	drcArea,
+        {"area",	 5,	5,	drcArea, "layers area horizon why"},
-    "layers area horizon why"},
+        {"off_grid",	 4,	4,	drcOffGrid, "layers pitch why"},
-        {"off_grid",	 4,	4,	drcOffGrid,
+        {"maxwidth",	 4,	6,	drcMaxwidth, "layers maxwidth bends why"},
-    "layers pitch why"},
+	{"cifstyle",	 2,	2,	drcCifSetStyle, "cif_style"},
-        {"maxwidth",	 4,	6,	drcMaxwidth,
+	{"cifwidth",	 4,	4,	drcCifWidth, "layers width why"},
-    "layers maxwidth bends why"},
-	{"cifstyle",	 2,	2,	drcCifSetStyle,
-    "cif_style"},
-	{"cifwidth",	 4,	4,	drcCifWidth,
-    "layers width why"},
 	{"cifspacing",	 6,	6,	drcCifSpacing,
     "layers1 layers2 separation adjacency why"},
-	{"cifarea",	 5,	5,	drcCifArea,
+	{"cifarea",	 5,	5,	drcCifArea, "layers area horizon why"},
-    "layers area horizon why"},
+	{"cifmaxwidth",	 5,	5,	drcCifMaxwidth, "layers maxwidth bends why"},
-	{"cifmaxwidth",	 5,	5,	drcCifMaxwidth,
-    "layers maxwidth bends why"},
 	{"rectangle",	5,	5,	drcRectangle,
     "layers maxwidth [even|odd|any] why"},
 	{0}
@@ -1695,7 +1756,7 @@ drcMaxwidth(argc, argv)
 	        if (PlaneMaskHasPlane(pmask2, plane2))
 		    break;
 
-	    if (plane2 == plane)
+	    if (PlaneMaskHasPlane(pmask, plane2))
 		TechError("Warning:  Exclude types for \"maxwidth\" are on the "
 			"same plane and so cannot be checked.\n");
 	}
@@ -3634,6 +3695,84 @@ drcRectangle(argc, argv)
     return maxwidth;
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * drcException, drcExemption --
+ *
+ * Process a DRC exception declaration
+ * This is of the form:
+ *
+ *	exception exception_name|none
+ * or
+ *	exemption exemption_name|none
+ *
+ * e.g,
+ *
+ *	exception SRAM
+ *	exemption SRAM
+ *
+ * The exception_name or exemption_name is the suffix part of a MASKHINTS_*
+ * property name;  e.g., the name SRAM corresponds to a property called
+ * MASKHINTS_SRAM.  This declaration is followed by a block of DRC rules
+ * that are subject to the exception or the exemption.  An exception is the
+ * opposite of an exemption:  If a rule is excepted, then the rule applies
+ * within areas delineated by bounding boxes defined by the
+ * MASKHINTS_<exception_name> property.  If a rule is exempted, then the
+ * rule applies only outside of areas delineated by bounding boxes defined
+ * by the MASKHINTS_<exemption_name> property.  The block of rules subject
+ * to the exemption or exception ends with another exception or exemption
+ * declaration.  If the following rules are not to be excepted or exempted
+ * at all, then use "exception none" or "exemption none".
+ *
+ * Results:
+ *	Returns 0.
+ *
+ * Side effects:
+ *	Updates drcCurException.  drcCurException contains the index in
+ *	the lower 7 bits, and a flag in the upper bit (0 = exception rule,
+ *	1 = exemption rule).  The index can be recovered by masking off
+ *	the upper bit.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+int
+drcException(argc, argv)
+    int argc;
+    char *argv[];
+{
+    int i;
+
+    if (DRCCurStyle == NULL) return 0;
+
+    /* Assume that argc must be 2 because the parser insists upon it */
+
+    if (!strcmp(argv[1], "none"))
+	drcCurException = DRC_EXCEPTION_NONE;
+    else
+	drcCurException = drcExceptionCreate(argv[1]);
+    return (0);
+}
+
+int
+drcExemption(argc, argv)
+    int argc;
+    char *argv[];
+{
+    int i;
+
+    if (DRCCurStyle == NULL) return 0;
+
+    /* Assume that argc must be 2 because the parser insists upon it */
+
+    if (!strcmp(argv[1], "none"))
+	drcCurException = DRC_EXCEPTION_NONE;
+    else
+	drcCurException = drcExceptionCreate(argv[1]) | DRC_EXCEPTION_MASK;
+    return (0);
+}
+
 /*
  * ----------------------------------------------------------------------------
  *
@@ -4119,6 +4258,7 @@ drcTechFinalStyle(style)
 		    if (dp->drcc_dist > next->drcc_dist) continue;
 		    if (dp->drcc_cdist > next->drcc_cdist) continue;
 		    if (dp->drcc_plane != next->drcc_plane) continue;
+		    if (dp->drcc_exception != next->drcc_exception) continue;
 		    if (dp->drcc_flags & DRC_REVERSE)
 		    {
 			if (!(next->drcc_flags & DRC_REVERSE)) continue;

drc/drc.h

@@ -36,6 +36,7 @@ typedef struct drccookie
     TileTypeBitMask   drcc_mask;	/* Legal types on RHS */
     TileTypeBitMask   drcc_corner;	/* Types that trigger corner check */
     unsigned short    drcc_flags;	/* Miscellaneous flags, see below. */
+    unsigned char     drcc_exception;	/* Index to list of exceptions */
     int		      drcc_edgeplane;	/* Plane of edge */
     int		      drcc_plane;	/* Index of plane on which to check
 					 * legal types. */
@@ -91,6 +92,11 @@ typedef struct drccookie
 #define DRC_UNPROCESSED 		CLIENTDEFAULT
 #define DRC_PROCESSED 			1
 
+/* drcc_exception defaults to 255 meaning no exceptions/exemptions */
+#define	DRC_EXCEPTION_NONE ((unsigned char)0xff)
+/* The high bit of the value determines if this is an exception or an exemption. */
+#define DRC_EXCEPTION_MASK ((unsigned char)0x80)
+
 /*
  * Background DRC (DRC Idle proc) for Tcl-based Magic
  */
@@ -177,6 +183,8 @@ typedef struct drcstyle
     unsigned short	DRCFlags;	/* Option flags */
     char		**DRCWhyList;	/* Indexed list of "why" text strings */
     int			DRCWhySize;	/* Length of DRCWhyList */
+    char		**DRCExceptionList; /* Indexed list of DRC exceptions */
+    int			DRCExceptionSize;   /* Length of DRCExceptionList */
     PaintResultType	DRCPaintTable[NP][NT][NT];
 } DRCStyle;
 

ext2spice/ext2hier.c

@@ -634,7 +634,7 @@ subcktHierVisit(
 
     if (hasports || is_top)
 	return subcktVisit(use, hierName, is_top);
-    else if (def->def_flags & DEF_NODEVICES)
+    else if ((def->def_flags & DEF_NODEVICES) && (!isStub))
 	return 0;
     else
 	return subcktVisit(use, hierName, is_top);
@@ -1088,6 +1088,7 @@ spcdevHierVisit(
 
 	    if (!has_model)
 	    {
+		fprintf(esSpiceF, " ");
 		esSIvalue(esSpiceF, 1.0E-15 * (double)sdM * (double)dev->dev_cap);
 		spcHierWriteParams(hc, dev, scale, l, w, sdM, FALSE);
 	    }
@@ -1138,6 +1139,7 @@ spcdevHierVisit(
 
 	    if (!has_model)
 	    {
+		fprintf(esSpiceF, " ");
 		esSIvalue(esSpiceF, 1.0E-15 * (double)sdM * (double)dev->dev_cap);
 		spcHierWriteParams(hc, dev, scale, l, w, sdM, FALSE);
 	    }

ext2spice/ext2spice.c

@@ -3140,6 +3140,7 @@ spcdevVisit(
 
 	    if (!has_model)
 	    {
+		fprintf(esSpiceF, " ");
 		esSIvalue(esSpiceF, 1.0E-15 * (double)sdM * (double)dev->dev_cap);
 		spcWriteParams(dev, hierName, scale, l, w, sdM, FALSE);
 	    }
@@ -3186,6 +3187,7 @@ spcdevVisit(
 
 	    if (!has_model)
 	    {
+		fprintf(esSpiceF, " ");
 		esSIvalue(esSpiceF, 1.0E-15 * (double)sdM * (double)dev->dev_cap);
 		spcWriteParams(dev, hierName, scale, l, w, sdM, FALSE);
 	    }

extflat/EFbuild.c

@@ -2238,6 +2238,14 @@ efNodeMerge(node1ptr, node2ptr)
     if (removing->efnode_flags & EF_SUBS_NODE)
 	keeping->efnode_flags |= EF_SUBS_NODE;
 
+    /*
+     * If "removing" has the EF_GLOB_SUBS_NODE flag set, then copy the
+     * port record in the flags to "keeping".
+     */
+    if (removing->efnode_flags & EF_GLOB_SUBS_NODE)
+	keeping->efnode_flags |= EF_GLOB_SUBS_NODE;
+
+    /* If EFSaveLocs is set, then merge any disjoint segments from
     /* If EFSaveLocs is set, then merge any disjoint segments from
      * removing to keeping.
      */

extract/ExtBasic.c

@@ -326,7 +326,7 @@ extBasic(def, outFile)
     }
 
     /* Check for "device", as it modifies handling of parasitics */
-    propptr = (char *)DBPropGet(def, "device", &propfound);
+    propptr = DBPropGetString(def, "device", &propfound);
     if (propfound)
     {
 	/* Remove parasitics from local nodes */
@@ -1702,7 +1702,7 @@ extOutputParameters(def, transList, outFile)
      * and device name, and if detected, add the type corresponding to the
      * device name to the mask so it gets handled, too.
      */
-    propptr = DBPropGet(def, "device", &propfound);
+    propptr = DBPropGetString(def, "device", &propfound);
     if (propfound)
     {
 	char *devname;
@@ -1835,6 +1835,8 @@ extOutputDevParams(reg, devptr, outFile, length, width, areavec, perimvec)
     ParamList *chkParam;
     HashEntry *he;
     ResValue resvalue;
+    LabRegion *node;	/* Node connected to gate terminal */
+    LabelList *ll;	/* Gate's label list */
 
     for (chkParam = devptr->exts_deviceParams; chkParam
 		!= NULL; chkParam = chkParam->pl_next)
@@ -1966,6 +1968,34 @@ extOutputDevParams(reg, devptr, outFile, length, width, areavec, perimvec)
 		break;
 	}
     }
+
+    /* If there are device attribute labels (labels attached to the device
+     * type ending with "^") with "=" in them, then treat them as extra
+     * parameters.  Output each one and remove the gate attribute property
+     * from the label.
+     */
+
+    node = (LabRegion *)ExtGetRegion(reg->treg_tile, reg->treg_dinfo);
+    for (ll = node->lreg_labels; ll; ll = ll->ll_next)
+    {
+	if (ll->ll_attr == LL_GATEATTR)
+	{
+	    char cs, *ct, *cp = ll->ll_label->lab_text;
+	    if (strchr(cp, '=') != NULL)
+	    {
+		/* Since this is an attribute label, it has a special character
+		 * at the end, which needs to be stripped off while printing
+		 * and then put back again.
+		 */
+		ct = ll->ll_label->lab_text + strlen(ll->ll_label->lab_text) - 1;
+		cs = *ct;
+		*ct = '\0';
+		fprintf(outFile, " %s", ll->ll_label->lab_text);
+		ll->ll_attr = LL_NOATTR;
+		*ct = cs;
+	    }
+	}
+    }
 }
 
 /* Structures used by extTermAPFunc() for storing area and perimeter data */
@@ -2725,6 +2755,56 @@ extOutputDevices(def, transList, outFile)
 			/* get corrected by extComputeEffectiveLW().	*/
 			length = (extTransRec.tr_gatelen - width) / 2;
 		    }
+
+		    if ((n == 1) && (length == 0) && (extTransRec.tr_gatelen == 0))
+		    {
+			/* If a one-terminal device has not recorded any
+			 * gate length, then get W and L from the bounding
+			 * box of the device.  This routine could be much
+			 * better optimized but it is probably not worth
+			 * the effort.  Just reusing the code from above
+			 * for creating extSpecialDevice, a list of device
+			 * tiles.  Note that W and L are not distinguishable
+			 * and hopefully the PDK defines the device by area
+			 * and perimeter.
+			 */
+			LinkedTile *lt;
+			Rect devbbox, ltbox;
+
+			extSpecialDevice = (LinkedTile *)NULL;
+
+			arg.fra_uninit = (ClientData)extTransRec.tr_gatenode;
+			arg.fra_region = (ExtRegion *)reg;
+			arg.fra_each = extSDTileFunc;
+			ExtFindNeighbors(reg->treg_tile, reg->treg_dinfo,
+					arg.fra_pNum, &arg);
+
+			arg.fra_uninit = (ClientData) reg;
+			arg.fra_region = (ExtRegion *) extTransRec.tr_gatenode;
+			arg.fra_each = (int (*)()) NULL;
+			ExtFindNeighbors(reg->treg_tile, reg->treg_dinfo,
+					arg.fra_pNum, &arg);
+
+			lt = extSpecialDevice;
+			if (lt)
+			{
+			    TiToRect(lt->t, &devbbox);
+			    for (; lt; lt = lt->t_next)
+			    {
+				TiToRect(lt->t, &ltbox);
+				GeoInclude(&ltbox, &devbbox);
+			    }
+			    free_magic1_t mm1 = freeMagic1_init();
+			    for (lt = extSpecialDevice; lt; lt = lt->t_next)
+				freeMagic1(&mm1, (char *)lt);
+			    freeMagic1_end(&mm1);
+			}
+			length = devbbox.r_xtop - devbbox.r_xbot;
+			/* Width was likely a perimeter value and will
+			 * be recalculated as the actual device width.
+			 */
+			width = devbbox.r_ytop - devbbox.r_ybot;
+		    }
 		}
 
 		/*------------------------------------------------------*/

extract/ExtCell.c

@@ -594,7 +594,7 @@ extHeader(def, f)
     /* are to be passed to instances of the cell	*/
     /* (created by defining property "parameter")	*/
 
-    propvalue = (char *)DBPropGet(def, "parameter", &propfound);
+    propvalue = DBPropGetString(def, "parameter", &propfound);
     if (propfound)
     {
 	// Use device parameter table to store the cell def parameters,

extract/ExtCouple.c

@@ -1289,6 +1289,14 @@ extFindOverlap(tp, area, esws)
     TileType tin = TiGetType(bp->b_inside);
     TileType tout = TiGetType(bp->b_outside);
 
+    /* Get residues
+     * (Note:  Isn't it better to include contacts in the tables?)
+     */
+    if (DBIsContact(tin))
+	tin = DBPlaneToResidue(tin, esws->plane_of_boundary);
+    if (DBIsContact(tout))
+	tout = DBPlaneToResidue(tout, esws->plane_of_boundary);
+
     pMask = ExtCurStyle->exts_sideOverlapOtherPlanes[tin][tout];
     extOverlapDef = esws->def;
 

extract/ExtHier.c

@@ -354,8 +354,8 @@ extHierConnections(ha, cumFlat, oneFlat)
 	if (!(lab->lab_flags & LABEL_STICKY)) continue;
 
 	r = lab->lab_rect;
+	if (!GEO_TOUCH(&r, &ha->ha_subArea)) continue;
 	GEOCLIP(&r, &ha->ha_subArea);
-	if (GEO_RECTNULL(&r)) continue;
 
 	cumDef = cumFlat->et_use->cu_def;
 	connected = &DBConnectTbl[lab->lab_type];

extract/ExtNghbors.c

@@ -614,6 +614,7 @@ termtop:
 
 termdone:
 	/* (continue) */
+	(void)0; /* older compilers need a statement after the label to prevent a compile error */
     }
     
     /* Clean up---Put the ClientData entries in the tiles back to

extract/ExtSubtree.c

@@ -251,6 +251,17 @@ extSubtree(parentUse, reg, f)
 			if (result == 0) {
 			    /* If result == FALSE then ha.ha_interArea is invalid. */
 			    ha.ha_interArea = rlab;
+			    /* Ensure that the interaction area is not zero */
+			    if (ha.ha_interArea.r_xtop - ha.ha_interArea.r_xbot == 0)
+			    {
+				ha.ha_interArea.r_xtop++;
+				ha.ha_interArea.r_xbot--;
+			    }
+			    if (ha.ha_interArea.r_ytop - ha.ha_interArea.r_ybot == 0)
+			    {
+				ha.ha_interArea.r_ytop++;
+				ha.ha_interArea.r_ybot--;
+			    }
 			    result = 1;
 			}
 			else
@@ -779,6 +790,7 @@ extSubtreeFunc(scx, ha)
      */
     ha->ha_subArea = use->cu_bbox;
     GEOCLIP(&ha->ha_subArea, &ha->ha_interArea);
+
     hy.hy_area = &ha->ha_subArea;
     hy.hy_target = oneFlat->et_use;
     hy.hy_prefix = TRUE;

graphics/grMain.c

@@ -63,7 +63,6 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include <unistd.h>
 
 #include "utils/magic.h"
-#include "utils/magsgtty.h"
 #include "textio/textio.h"
 #include "utils/geometry.h"
 #include "utils/hash.h"

graphics/grNull.c

@@ -20,7 +20,6 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "utils/magsgtty.h"
 #include "utils/magic.h"
 #include "utils/geometry.h"
 #include "windows/windows.h"

graphics/grOGL1.c

@@ -17,7 +17,6 @@
 #include <signal.h>
 
 #include "utils/magic.h"
-#include "utils/magsgtty.h"
 #include "utils/geometry.h"
 #include "graphics/graphics.h"
 #include "windows/windows.h"

graphics/grOGL4.c

@@ -22,7 +22,6 @@
 #include <X11/Xlib.h>
 
 #include "utils/magic.h"
-#include "utils/magsgtty.h"
 #include "textio/textio.h"
 #include "utils/geometry.h"
 #include "graphics/graphics.h"

graphics/grTCairo1.c

@@ -28,7 +28,6 @@
 #include "utils/main.h"
 #include "utils/magic.h"
 #include "utils/malloc.h"
-#include "utils/magsgtty.h"
 #include "utils/geometry.h"
 #include "windows/windows.h"
 #include "graphics/graphics.h"

graphics/grTCairo4.c

@@ -15,7 +15,6 @@
 
 #include "tcltk/tclmagic.h"
 #include "utils/magic.h"
-#include "utils/magsgtty.h"
 #include "textio/textio.h"
 #include "utils/geometry.h"
 #include "windows/windows.h"

graphics/grTOGL1.c

@@ -26,7 +26,6 @@
 #include "utils/main.h"
 #include "utils/magic.h"
 #include "utils/malloc.h"
-#include "utils/magsgtty.h"
 #include "utils/geometry.h"
 #include "windows/windows.h"
 #include "graphics/graphics.h"

graphics/grTOGL4.c

@@ -13,7 +13,6 @@
 
 #include "tcltk/tclmagic.h"
 #include "utils/magic.h"
-#include "utils/magsgtty.h"
 #include "textio/textio.h"
 #include "utils/geometry.h"
 #include "windows/windows.h"

graphics/grTk1.c

@@ -23,7 +23,6 @@
 #include "utils/main.h"
 #include "utils/magic.h"
 #include "utils/malloc.h"
-#include "utils/magsgtty.h"
 #include "utils/geometry.h"
 #include "windows/windows.h"
 #include "graphics/graphics.h"

graphics/grTk4.c

@@ -13,7 +13,6 @@
 
 #include "tcltk/tclmagic.h"
 #include "utils/magic.h"
-#include "utils/magsgtty.h"
 #include "textio/textio.h"
 #include "utils/geometry.h"
 #include "windows/windows.h"

graphics/grX11su1.c

@@ -31,7 +31,6 @@
 #include <X11/Xutil.h>
 
 #include "utils/magic.h"
-#include "utils/magsgtty.h"
 #include "textio/textio.h"
 #include "utils/geometry.h"
 #include "textio/txcommands.h"

graphics/grX11su4.c

@@ -22,7 +22,6 @@
 #include <X11/Xlib.h>
 
 #include "utils/magic.h"
-#include "utils/magsgtty.h"
 #include "textio/textio.h"
 #include "utils/geometry.h"
 #include "graphics/graphics.h"

lef/defRead.c

@@ -1359,15 +1359,21 @@ DefReadLocation(
 
 	if (use->cu_def->cd_flags & CDFIXEDBBOX)
 	{
-	    char *propval;
+	    PropertyRecord *proprec;
 	    bool found;
 
-	    propval = (char *)DBPropGet(use->cu_def, "FIXED_BBOX", &found);
+	    proprec = DBPropGet(use->cu_def, "FIXED_BBOX", &found);
 	    if (found)
 	    {
-		if (sscanf(propval, "%d %d %d %d", &rect.r_xbot, &rect.r_ybot,
+		if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
-			    &rect.r_xtop, &rect.r_ytop) == 4)
+			(proprec->prop_len == 4))
+		{
+		    rect.r_xbot = proprec->prop_value.prop_integer[0];
+		    rect.r_ybot = proprec->prop_value.prop_integer[1];
+		    rect.r_xtop = proprec->prop_value.prop_integer[2];
+		    rect.r_ytop = proprec->prop_value.prop_integer[3];
 		    r = ▭
+		}
 	    }
 	}
     }
@@ -2453,7 +2459,7 @@ DefRead(
     FILE *f;
     char *filename;
     const char *token;
-    char *bboxstr;
+    PropertyRecord *proprec;
     int keyword, dscale, total;
     float oscale;
     Rect *dierect;
@@ -2605,14 +2611,17 @@ DefRead(
 		break;
 	    case DEF_DIEAREA:
 		dierect = LefReadRect(f, 0, oscale);
-		bboxstr = mallocMagic(40);
+		proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
-		sprintf(bboxstr, "%d %d %d %d",
+				2 * sizeof(int));
-			dierect->r_xbot,
+		proprec->prop_type = PROPERTY_TYPE_DIMENSION;
-			dierect->r_ybot,
+		proprec->prop_len = 4;
-			dierect->r_xtop,
+		proprec->prop_value.prop_integer[0] = dierect->r_xbot;
-			dierect->r_ytop);
+		proprec->prop_value.prop_integer[1] = dierect->r_ybot;
+		proprec->prop_value.prop_integer[2] = dierect->r_xtop;
+		proprec->prop_value.prop_integer[3] = dierect->r_ytop;
 		if (rootDef == NULL) rootDef = DefNewCell(inName);
-		DBPropPut(rootDef, "FIXED_BBOX", bboxstr);
+		DBPropPut(rootDef, "FIXED_BBOX", proprec);
+
 		LefEndStatement(f);
 		break;
 	    case DEF_PROPERTYDEFINITIONS:

lef/defWrite.c

@@ -108,7 +108,7 @@ defWriteHeader(
     float oscale,
     int units)		/* Units for UNITS; could be derived from oscale */
 {
-    char *propvalue;
+    PropertyRecord *proprec;
     bool propfound;
 
     TxPrintf("Diagnostic:  Write DEF header for cell %s\n", def->cd_name);
@@ -141,15 +141,20 @@ defWriteHeader(
     /* For DIEAREA, use the FIXED_BBOX property if present.  Otherwise,	*/
     /* use the extents of geometry (CellDef bounding box)		*/
 
-    propvalue = (char *)DBPropGet(def, "FIXED_BBOX", &propfound);
+    proprec = DBPropGet(def, "FIXED_BBOX", &propfound);
     if (propfound)
     {
 	Rect bbox;
 
 	/* Die area, taken from the declared FIXED_BBOX.		*/
-	if (sscanf(propvalue, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
+	if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
-		&bbox.r_xtop, &bbox.r_ytop) == 4)
+			(proprec->prop_len == 4))
-        {
+	{
+	    bbox.r_xbot = proprec->prop_value.prop_integer[0];
+	    bbox.r_ybot = proprec->prop_value.prop_integer[1];
+	    bbox.r_xtop = proprec->prop_value.prop_integer[2];
+	    bbox.r_ytop = proprec->prop_value.prop_integer[3];
+
 	     fprintf(f, "   DIEAREA ( %.10g %.10g ) ( %.10g %.10g ) ;\n",
 			(float)bbox.r_xbot * oscale,
 			(float)bbox.r_ybot * oscale,
@@ -2786,15 +2791,21 @@ arrayDefFunc(
 
     if (use->cu_def->cd_flags & CDFIXEDBBOX)
     {
-	char *propval;
+	PropertyRecord *proprec;
 	bool found;
 
-	propval = (char *)DBPropGet(use->cu_def, "FIXED_BBOX", &found);
+	proprec = DBPropGet(use->cu_def, "FIXED_BBOX", &found);
 	if (found)
 	{
-	    if (sscanf(propval, "%d %d %d %d", &rect.r_xbot, &rect.r_ybot,
+	    if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
-			&rect.r_xtop, &rect.r_ytop) == 4)
+			(proprec->prop_len == 4))
+	    {
+		rect.r_xbot = proprec->prop_value.prop_integer[0];
+		rect.r_ybot = proprec->prop_value.prop_integer[1];
+		rect.r_xtop = proprec->prop_value.prop_integer[2];
+		rect.r_ytop = proprec->prop_value.prop_integer[3];
 		r = ▭
+	    }
 	}
     }
 
@@ -2844,15 +2855,20 @@ defComponentFunc(
     xoff = yoff = 0;
     if (cellUse->cu_def->cd_flags & CDFIXEDBBOX)
     {
-	char *propval;
+	PropertyRecord *proprec;
 	bool found;
 
-	propval = (char *)DBPropGet(cellUse->cu_def, "FIXED_BBOX", &found);
+	proprec = DBPropGet(cellUse->cu_def, "FIXED_BBOX", &found);
 	if (found)
 	{
-	    if (sscanf(propval, "%d %d %d %d", &rect.r_xbot, &rect.r_ybot,
+	    if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
-			&rect.r_xtop, &rect.r_ytop) == 4)
+			(proprec->prop_len == 4))
 	    {
+	 	rect.r_xbot = proprec->prop_value.prop_integer[0];
+	 	rect.r_ybot = proprec->prop_value.prop_integer[1];
+	 	rect.r_xtop = proprec->prop_value.prop_integer[2];
+	 	rect.r_ytop = proprec->prop_value.prop_integer[3];
+
 		r = ▭
 		GeoTransRect(&cellUse->cu_transform, &rect, &bbrect);
 		GeoTransRect(&cellUse->cu_transform, &cellUse->cu_def->cd_bbox, &defrect);

lef/lefRead.c

@@ -2150,6 +2150,7 @@ LefReadMacro(
     int keyword, pinNum, propsize, result;
     float x, y;
     bool has_size, is_imported = FALSE, propfound;
+    PropertyRecord *proprec;
     Rect lefBBox;
     Point gdsOffset;	/* Difference between GDS and LEF coordinates */
 
@@ -2250,7 +2251,12 @@ LefReadMacro(
 		    sprintf(tsave + strlen(tsave), " %s", token);
 		    token = LefNextToken(f, TRUE);
 		}
-		DBPropPut(lefMacro, "LEFclass", StrDup((char **)NULL, tsave + 1));
+		proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
+				strlen(tsave + 1) - 7);
+		proprec->prop_type = PROPERTY_TYPE_STRING;
+		proprec->prop_len = strlen(tsave + 1);
+		strcpy(proprec->prop_value.prop_string, tsave + 1);
+		DBPropPut(lefMacro, "LEFclass", proprec);
 		break;
 	    case LEF_SIZE:
 		token = LefNextToken(f, TRUE);
@@ -2294,7 +2300,12 @@ origin_error:
 		    sprintf(tsave + strlen(tsave), " %s", token);
 		    token = LefNextToken(f, TRUE);
 		}
-		DBPropPut(lefMacro, "LEFsymmetry", StrDup((char **)NULL, tsave + 1));
+		proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
+				strlen(tsave + 1) - 7);
+		proprec->prop_type = PROPERTY_TYPE_STRING;
+		proprec->prop_len = strlen(tsave + 1);
+		strcpy(proprec->prop_value.prop_string, tsave + 1);
+		DBPropPut(lefMacro, "LEFsymmetry", proprec);
 		break;
 	    case LEF_SOURCE:
 		token = LefNextToken(f, TRUE);
@@ -2305,12 +2316,19 @@ origin_error:
 	    case LEF_SITE:
 		token = LefNextToken(f, TRUE);
 		if (*token != '\n')
-		    DBPropPut(lefMacro, "LEFsite", StrDup((char **)NULL, token));
+		{
+		    proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
+				strlen(token) - 7);
+		    proprec->prop_type = PROPERTY_TYPE_STRING;
+		    proprec->prop_len = strlen(token);
+		    strcpy(proprec->prop_value.prop_string, token);
+		    DBPropPut(lefMacro, "LEFsite", proprec);
+		}
 		LefEndStatement(f);
 		break;
 	    case LEF_PROPERTY:
 		/* Append property key:value pairs to the cell property LEFproperties */
-		propval = (char *)DBPropGet(lefMacro, "LEFproperties", &propfound);
+		propval = DBPropGetString(lefMacro, "LEFproperties", &propfound);
 		if (propfound)
 		    propsize = strlen(propval);
 		else
@@ -2322,14 +2340,19 @@ origin_error:
 		    char *propext;
 		    sprintf(tsave, "%.127s", token);
 		    token = LefNextToken(f, TRUE);
-		    propext = (char *)mallocMagic(propsize + strlen(tsave) +
-			    strlen(token) + 4);
-		    if (propsize > 0)
-			sprintf(propext, "%s %s %s", propval, tsave, token);
-		    else
-			sprintf(propext, "%s %s", tsave, token);
 		    
-		    DBPropPut(lefMacro, "LEFproperties", StrDup((char **)NULL, propext));
+		    proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
+				propsize + strlen(tsave) + strlen(token) - 3);
+		    proprec->prop_type = PROPERTY_TYPE_STRING;
+		    proprec->prop_len = propsize + strlen(tsave) + strlen(token) + 4;
+
+		    if (propsize > 0)
+			sprintf(proprec->prop_value.prop_string, "%s %s %s",
+					propval, tsave, token);
+		    else
+			sprintf(proprec->prop_value.prop_string, "%s %s", tsave, token);
+
+		    DBPropPut(lefMacro, "LEFproperties", proprec);
 		}
 		LefEndStatement(f);
 		break;
@@ -2405,11 +2428,16 @@ foreign_error:
 	if (has_size)
 	{
 	    lefMacro->cd_flags |= CDFIXEDBBOX;
-	    propval = (char *)mallocMagic(40);
+	    proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
-	    sprintf(propval, "%d %d %d %d",
+			(2 * sizeof(int)));
-		    lefBBox.r_xbot, lefBBox.r_ybot,
+	    proprec->prop_type = PROPERTY_TYPE_DIMENSION;
-		    lefBBox.r_xtop, lefBBox.r_ytop);
+	    proprec->prop_len = 4;
-	    DBPropPut(lefMacro, "FIXED_BBOX", propval);
+	    proprec->prop_value.prop_integer[0] = lefBBox.r_xbot;
+	    proprec->prop_value.prop_integer[1] = lefBBox.r_ybot;
+	    proprec->prop_value.prop_integer[2] = lefBBox.r_xtop;
+	    proprec->prop_value.prop_integer[3] = lefBBox.r_ytop;
+
+	    DBPropPut(lefMacro, "FIXED_BBOX", proprec);
 	}
     }
     else
@@ -2419,11 +2447,16 @@ foreign_error:
 	if (has_size)
 	{
 	    lefMacro->cd_flags |= CDFIXEDBBOX;
-	    propval = (char *)mallocMagic(40);
+	    proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
-	    sprintf(propval, "%d %d %d %d",
+			(2 * sizeof(int)));
-		    lefBBox.r_xbot, lefBBox.r_ybot,
+	    proprec->prop_type = PROPERTY_TYPE_DIMENSION;
-		    lefBBox.r_xtop, lefBBox.r_ytop);
+	    proprec->prop_len = 4;
-	    DBPropPut(lefMacro, "FIXED_BBOX", propval);
+	    proprec->prop_value.prop_integer[0] = lefBBox.r_xbot;
+	    proprec->prop_value.prop_integer[1] = lefBBox.r_ybot;
+	    proprec->prop_value.prop_integer[2] = lefBBox.r_xtop;
+	    proprec->prop_value.prop_integer[3] = lefBBox.r_ytop;
+
+	    DBPropPut(lefMacro, "FIXED_BBOX", proprec);
 	}
 	else
 	{
@@ -2432,13 +2465,17 @@ foreign_error:
 
 	    /* Set the placement bounding box property to the current bounding box */
 	    lefMacro->cd_flags |= CDFIXEDBBOX;
-	    propval = (char *)mallocMagic(40);
+	    lefMacro->cd_flags |= CDFIXEDBBOX;
-	    sprintf(propval, "%d %d %d %d",
+	    proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
-		    lefMacro->cd_bbox.r_xbot,
+			(2 * sizeof(int)));
-		    lefMacro->cd_bbox.r_ybot,
+	    proprec->prop_type = PROPERTY_TYPE_DIMENSION;
-		    lefMacro->cd_bbox.r_xtop,
+	    proprec->prop_len = 4;
-		    lefMacro->cd_bbox.r_ytop);
+	    proprec->prop_value.prop_integer[0] = lefMacro->cd_bbox.r_xbot;
-	    DBPropPut(lefMacro, "FIXED_BBOX", propval);
+	    proprec->prop_value.prop_integer[1] = lefMacro->cd_bbox.r_ybot;
+	    proprec->prop_value.prop_integer[2] = lefMacro->cd_bbox.r_xtop;
+	    proprec->prop_value.prop_integer[3] = lefMacro->cd_bbox.r_ytop;
+
+	    DBPropPut(lefMacro, "FIXED_BBOX", proprec);
 	    DRCCheckThis(lefMacro, TT_CHECKPAINT, &lefMacro->cd_bbox);
 	}
     }
@@ -2453,7 +2490,13 @@ foreign_error:
     /* i.e., setting it to "FALSE" would be ineffective.	*/
 
     if (!is_imported)
-	DBPropPut(lefMacro, "LEFview", StrDup((char **)NULL, "TRUE"));
+    {
+	proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+	proprec->prop_type = PROPERTY_TYPE_STRING;
+	proprec->prop_len = 4;
+	strcpy(proprec->prop_value.prop_string, "TRUE");
+	DBPropPut(lefMacro, "LEFview", proprec);
+    }
 
     DBWAreaChanged(lefMacro, &lefMacro->cd_bbox, DBW_ALLWINDOWS,
 		&DBAllButSpaceBits);

lef/lefWrite.c

@@ -328,14 +328,14 @@ lefWriteHeader(
 	{
 	    fprintf(f, "SITE %s\n", siteDef->cd_name);
 
-	    propvalue = (char *)DBPropGet(siteDef, "LEFsymmetry", &propfound);
+	    propvalue = DBPropGetString(siteDef, "LEFsymmetry", &propfound);
 	    if (propfound)
 		fprintf(f, IN0 "SYMMETRY %s ;\n", propvalue);
 	    else
 		/* Usually core cells have symmetry Y only. */
 		fprintf(f, IN0 "SYMMETRY Y ;\n");
 
-	    propvalue = (char *)DBPropGet(siteDef, "LEFclass", &propfound);
+	    propvalue = DBPropGetString(siteDef, "LEFclass", &propfound);
 	    if (propfound)
 		fprintf(f, IN0 "CLASS %s ;\n", propvalue);
 	    else
@@ -345,10 +345,20 @@ lefWriteHeader(
 	    boundary = siteDef->cd_bbox;
 	    if (siteDef->cd_flags & CDFIXEDBBOX)
 	    {
-		propvalue = (char *)DBPropGet(def, "FIXED_BBOX", &propfound);
+		PropertyRecord *proprec;
+
+		proprec = DBPropGet(def, "FIXED_BBOX", &propfound);
 		if (propfound)
-		    sscanf(propvalue, "%d %d %d %d", &boundary.r_xbot,
+		{
-			    &boundary.r_ybot, &boundary.r_xtop, &boundary.r_ytop);
+		    if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
+				(proprec->prop_len == 4))
+		    {
+			boundary.r_xbot = proprec->prop_value.prop_integer[0];
+			boundary.r_ybot = proprec->prop_value.prop_integer[1];
+			boundary.r_xtop = proprec->prop_value.prop_integer[2];
+			boundary.r_ytop = proprec->prop_value.prop_integer[3];
+		    }
+		}
 	    }
 
 	    scale = CIFGetOutputScale(1000);	/* conversion to microns */
@@ -1288,7 +1298,7 @@ lefWriteMacro(
     /* default values are optional, so in this case we will leave those	*/
     /* entries blank.							*/
 
-    propvalue = (char *)DBPropGet(def, "LEFclass", &propfound);
+    propvalue = DBPropGetString(def, "LEFclass", &propfound);
     if (propfound)
     {
 	fprintf(f, IN0 "CLASS %s ;\n", propvalue);
@@ -1324,13 +1334,21 @@ lefWriteMacro(
 
     if (def->cd_flags & CDFIXEDBBOX)
     {
-	char *propvalue;
+	PropertyRecord *proprec;
 	bool found;
 
-	propvalue = (char *)DBPropGet(def, "FIXED_BBOX", &found);
+	proprec = DBPropGet(def, "FIXED_BBOX", &found);
 	if (found)
-	    sscanf(propvalue, "%d %d %d %d", &boundary.r_xbot,
+	{
-		    &boundary.r_ybot, &boundary.r_xtop, &boundary.r_ytop);
+	    if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
+			(proprec->prop_len == 4))
+	    {
+		boundary.r_xbot = proprec->prop_value.prop_integer[0];
+		boundary.r_ybot = proprec->prop_value.prop_integer[1];
+		boundary.r_xtop = proprec->prop_value.prop_integer[2];
+		boundary.r_ytop = proprec->prop_value.prop_integer[3];
+	    }
+	}
     }
 
     /* Check if (boundry less setback) is degenerate.  If so, then	*/
@@ -1358,11 +1376,11 @@ lefWriteMacro(
     lc.origin.p_x = 0;
     lc.origin.p_y = 0;
 
-    propvalue = (char *)DBPropGet(def, "LEFsymmetry", &propfound);
+    propvalue = DBPropGetString(def, "LEFsymmetry", &propfound);
     if (propfound)
 	fprintf(f, IN0 "SYMMETRY %s ;\n", propvalue);
 
-    propvalue = (char *)DBPropGet(def, "LEFsite", &propfound);
+    propvalue = DBPropGetString(def, "LEFsite", &propfound);
     if (propfound)
 	fprintf(f, IN0 "SITE %s ;\n", propvalue);
 
@@ -1821,20 +1839,24 @@ lefWriteMacro(
 	Rect layerBound, manualBound;
 	labelLinkedList *thislll;
 	bool propfound;
-	char *propvalue;
+	PropertyRecord *proprec;
 
 	/* If there is a property OBS_BBOX, then use the value of the	*/
 	/* defined box to set the minimum hidden area.  This will still	*/
 	/* get clipped to the setback.					*/
 
-	propvalue = (char *)DBPropGet(def, "OBS_BBOX", &propfound);
+	proprec = DBPropGet(def, "OBS_BBOX", &propfound);
 	if (propfound)
 	{
-	    if (sscanf(propvalue, "%d %d %d %d",
+	    if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
-			&(manualBound.r_xbot),
+			(proprec->prop_len == 4))
-			&(manualBound.r_ybot),
+	    {
-			&(manualBound.r_xtop),
+		manualBound.r_xbot = proprec->prop_value.prop_integer[0];
-			&(manualBound.r_ytop)) != 4)
+		manualBound.r_ybot = proprec->prop_value.prop_integer[1];
+		manualBound.r_xtop = proprec->prop_value.prop_integer[2];
+		manualBound.r_ytop = proprec->prop_value.prop_integer[3];
+	    }
+	    else
 	    {
 		TxError("Improper values for obstruction bounding box "
 				"OBS_BBOX property");
@@ -2016,7 +2038,7 @@ lefWriteMacro(
 
     /* If there are any properties saved in LEFproperties, write them out */
 
-    propvalue = (char *)DBPropGet(def, "LEFproperties", &propfound);
+    propvalue = DBPropGetString(def, "LEFproperties", &propfound);
     if (propfound)
     {
 	char *delim;
@@ -2094,7 +2116,7 @@ lefGetSites(
     bool propfound;
     char *propvalue;
 
-    propvalue = (char *)DBPropGet(def, "LEFsite", &propfound);
+    propvalue = DBPropGetString(def, "LEFsite", &propfound);
     if (propfound)
 	he = HashFind(lefSiteTbl, propvalue); /* FIXME return value not used from call to function with no side-effects (reevaluate this entire func purpose?) */
 
@@ -2124,7 +2146,7 @@ lefGetProperties(
     bool propfound;
     char *propvalue;
 
-    propvalue = (char *)DBPropGet(def, "LEFproperties", &propfound);
+    propvalue = DBPropGetString(def, "LEFproperties", &propfound);
     if (propfound)
     {
 	char *key;

magic/proto.magicrc.in

@@ -120,61 +120,61 @@ macro Control_XK_space "tool wiring"
 # Arrow keys (X11 versions only)
 macro XK_Left "scroll l .1 w"
 macro Shift_XK_Left "scroll l 1 w"
-macro Control_XK_Left "box grow w 1"
+macro Control_XK_Left "box grow w 1i"
-macro Control_Shift_XK_Left "box shrink e 1"
+macro Control_Shift_XK_Left "box shrink e 1i"
 macro XK_Right "scroll r .1 w"
 macro Shift_XK_Right "scroll r 1 w"
-macro Control_XK_Right "box grow e 1"
+macro Control_XK_Right "box grow e 1i"
-macro Control_Shift_XK_Right "box shrink w 1"
+macro Control_Shift_XK_Right "box shrink w 1i"
 macro XK_Up "scroll u .1 w"
 macro Shift_XK_Up "scroll u 1 w"
-macro Control_XK_Up "box grow n 1"
+macro Control_XK_Up "box grow n 1i"
-macro Control_Shift_XK_Up "box shrink s 1"
+macro Control_Shift_XK_Up "box shrink s 1i"
 macro XK_Down "scroll d .1 w"
 macro Shift_XK_Down "scroll d 1 w"
-macro Control_XK_Down "box grow s 1"
+macro Control_XK_Down "box grow s 1i"
-macro Control_Shift_XK_Down "box shrink n 1"
+macro Control_Shift_XK_Down "box shrink n 1i"
 # Keypad keys (X11 versions only)
 # Functions duplicated for use both with Num_Lock ON and OFF
 macro XK_KP_Delete "box size 0 0"
-macro XK_KP_Insert "box size 4 4"
+macro XK_KP_Insert "box size 4l 4l"
-macro XK_KP_0 "box size 7 2"
+macro XK_KP_0 "box size 7l 2l"
-macro Shift_XK_KP_0 "box size 7 2"
+macro Shift_XK_KP_0 "box size 7l 2l"
-macro XK_0 "box size 7 2"
+macro XK_0 "box size 7l 2l"
-macro Control_XK_KP_0 "box size 2 7"
+macro Control_XK_KP_0 "box size 2l 7l"
-macro Control_XK_KP_Insert "box size 2 7"
+macro Control_XK_KP_Insert "box size 2l 7l"
-macro XK_KP_End "move sw 1"
+macro XK_KP_End "move sw 1i"
-macro XK_KP_Down "move d 1"
+macro XK_KP_Down "move d 1i"
-macro XK_KP_2 "stretch d 1"
+macro XK_KP_2 "stretch d 1i"
 macro Shift_XK_KP_2 "stretch d 1"
-macro Shift_XK_KP_Down "stretch d 1"
+macro Shift_XK_KP_Down "move d 1"
 macro Control_XK_KP_Down "stretch d 1i"
-macro XK_2 "stretch d 1"
+macro XK_2 "stretch d 1i"
-macro XK_KP_Next "move se 1"
+macro XK_KP_Next "move se 1i"
-macro XK_KP_Left "move l 1"
+macro XK_KP_Left "move l 1i"
-macro XK_KP_4 "stretch l 1"
+macro XK_KP_4 "stretch l 1i"
 macro Shift_XK_KP_4 "stretch l 1"
-macro Shift_XK_KP_Left "stretch l 1"
+macro Shift_XK_KP_Left "move l 1"
 macro Control_XK_KP_Left "stretch l 1i"
-macro XK_4 "stretch l 1"
+macro XK_4 "stretch l 1i"
 macro XK_KP_Begin "findbox zoom"
 macro XK_KP_5 "findbox"
 macro Shift_XK_KP_5 "findbox"
 macro XK_5 "findbox"
-macro XK_KP_Right "move r 1"
+macro XK_KP_Right "move r 1i"
-macro XK_KP_6 "stretch r 1"
+macro XK_KP_6 "stretch r 1i"
 macro Shift_XK_KP_6 "stretch r 1"
-macro Shift_XK_KP_Right "stretch r 1"
+macro Shift_XK_KP_Right "move r 1"
 macro Control_XK_KP_Right "stretch r 1i"
-macro XK_6 "stretch r 1"
+macro XK_6 "stretch r 1i"
-macro XK_KP_Home "move nw 1"
+macro XK_KP_Home "move nw 1i"
-macro XK_KP_Up "move u 1"
+macro XK_KP_Up "move u 1i"
-macro XK_KP_8 "stretch u 1"
+macro XK_KP_8 "stretch u 1i"
 macro Shift_XK_KP_8 "stretch u 1"
-macro Shift_XK_KP_Up "stretch u 1"
+macro Shift_XK_KP_Up "move u 1"
 macro Control_XK_KP_Up "stretch u 1i"
-macro XK_8 "stretch u 1"
+macro XK_8 "stretch u 1i"
-macro XK_KP_Prior "move ne 1"
+macro XK_KP_Prior "move ne 1i"
 # Scroll wheel bindings
 macro XK_Pointer_Button4 "scroll u .05 w"
 macro XK_Pointer_Button5 "scroll d .05 w"

magic/symbol.map

@@ -58,6 +58,8 @@ MAGIC_8.0 {
            DBPlaneTypes;
            DBPrintUseId;
 	   DBPropGet;
+	   DBPropGetString;
+	   DBPropGetDouble;
            DBPutLabel;
            DBReComputeBbox;
            DBSeeTypesAll;

resis/ResRex.c

@@ -1356,7 +1356,7 @@ ResFixUpConnections(extDev, layoutDev, extNode, nodename)
     }
     if (extDev->subs == extNode)
     {
-	if ((subs = layoutDev->rd_fet_subs) != NULL)
+	if ((layoutDev->rd_nterms >= 4) && ((subs = layoutDev->rd_fet_subs) != NULL))
 	{
 	    if (subs->rn_name != NULL && notdecremented)
 	    {

resis/ResSimple.c

@@ -386,7 +386,7 @@ ResMoveDevices(node1, node2)
 	devptr = devptr->te_nextt;
 	if (device->rd_fet_gate == node1)
    	    device->rd_fet_gate = node2;
-	else if (device->rd_fet_subs == node1)
+	else if ((device->rd_nterms >= 4) && (device->rd_fet_subs == node1))
    	    device->rd_fet_subs = node2;
 	else if (device->rd_fet_source == node1)
 	    device->rd_fet_source = node2;

select/selDisplay.c

@@ -321,14 +321,20 @@ selRedisplayCellFunc(scx, window)
     if (scx->scx_use->cu_def->cd_flags & CDFIXEDBBOX)
     {
 	bool found;
-	char *propval;
+	PropertyRecord *proprec;
 
-	propval = (char *)DBPropGet(scx->scx_use->cu_def, "FIXED_BBOX", &found);
+	proprec = DBPropGet(scx->scx_use->cu_def, "FIXED_BBOX", &found);
 	if (found)
 	{
-	    if (sscanf(propval, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
+	    if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
-		    &bbox.r_xtop, &bbox.r_ytop) == 4)
+			(proprec->prop_len == 4))
+	    {
+		bbox.r_xbot = proprec->prop_value.prop_integer[0];
+		bbox.r_ybot = proprec->prop_value.prop_integer[1];
+		bbox.r_xtop = proprec->prop_value.prop_integer[2];
+		bbox.r_ytop = proprec->prop_value.prop_integer[3];
 		GeoTransRect(&scx->scx_trans, &bbox, &tmp);
+	    }
 	    else
 		found = FALSE;
 	}

select/selOps.c

@@ -1216,13 +1216,21 @@ SelectTransform(transform)
     SelectAndCopy2(EditRootDef);
 }
 
+/* Client data used by SelectExpand */
+
+typedef struct selExpData {
+    int sed_mask;	/* window mask */
+    int sed_type;	/* DB_EXPAND, etc. */
+    Rect *sed_box;	/* selection box if used, or NULL */
+} SelExpData;
+
 /*
  * ----------------------------------------------------------------------------
  *
  * SelectExpand --
  *
- * 	Expand all of the selected cells that are unexpanded, and
+ * 	Expand or unexpand all of the selected cells according to
- *	unexpand all of those that are expanded.
+ *	expandType.
  *
  * Results:
  *	None.
@@ -1230,58 +1238,166 @@ SelectTransform(transform)
  * Side effects:
  *	The contents of the selected cells will become visible or
  *	invisible on the display in the indicated window(s).
+ *	Both the cell in the layout and the selection are updated
+ *	so that they are synchonized with respect to the state of
+ *	visibility.
  *
  * ----------------------------------------------------------------------------
  */
 
 void
-SelectExpand(mask)
+SelectExpand(mask, expandType, rootBox)
     int mask;			/* Bits of this word indicate which
 				 * windows the selected cells will be
 				 * expanded in.
 				 */
+    int expandType;		/* Operation to perform:  Expand,
+				 * unexpand, or expand toggle.
+				 */
+    Rect *rootBox;		/* Area of root box, if selecting by
+				 * cursor box area.
+				 */
 {
-    extern int selExpandFunc();	/* Forward reference. */
+    /* Forward references */
+    extern int selExpandFunc();
 
-    (void) SelEnumCells(FALSE, (bool *) NULL, (SearchContext *) NULL,
+    SelExpData sed;
-	    selExpandFunc, INT2CD(mask));
+
+    sed.sed_type = expandType;
+    sed.sed_box = rootBox;
+    sed.sed_mask = mask;
+
+    if (rootBox != NULL)
+    {
+	SearchContext scx;
+
+	scx.scx_use = SelectUse;
+	scx.scx_area = *rootBox;
+	scx.scx_trans = GeoIdentityTransform;
+
+	SelEnumCells(FALSE, (bool *) NULL, &scx, selExpandFunc, &sed);
+	return;
+    }
+
+    SelEnumCells(FALSE, (bool *) NULL, (SearchContext *)NULL,
+	    	selExpandFunc, &sed);
 }
 
     /* ARGSUSED */
 int
-selExpandFunc(selUse, use, transform, mask)
+selExpandFunc(selUse, use, transform, sed)
     CellUse *selUse;		/* Use from selection. */
     CellUse *use;		/* Use to expand (in actual layout). */
     Transform *transform;	/* Not used. */
-    int mask;			/* Windows in which to expand. */
+    SelExpData *sed;		/* Information for expansion */
 {
-    /* Don't change expansion status of root cell:  screws up
+    int expandType = sed->sed_type;
-     * DBWAreaChanged (need to always have at least top-level
+    int mask = sed->sed_mask;
-     * cell be expanded).
+    Rect *rootBox = sed->sed_box;
-     */
 
-    if (use->cu_parent == NULL)
+    /* If a rootBox is provided, then we are here trying to sync the
+     * cells in the selection to those in the edit cell.  Need to
+     * follow the policy of expandType:  If DB_EXPAND_SURROUND, then
+     * selUse must be inside the rootBox.  If DB_EXPAND_OVERLAP, then
+     * selUse must ovelap the rootBox.
+     */
+    if (rootBox != NULL)
     {
-	TxError("Can't unexpand root cell of window.\n");
+	if ((expandType & DB_EXPAND_SURROUND_MASK) == DB_EXPAND_OVERLAP)
-	return 0;
+	{
+	    if (!GEO_OVERLAP(rootBox, &selUse->cu_bbox))
+		return 0;
+	}
+	else /* (expandType & DB_EXPAND_SURROUND_MASK) == DB_EXPAND_SURROUND */
+	{
+	    if (!GEO_SURROUND(rootBox, &selUse->cu_bbox))
+		return 0;
+	}
     }
 
-    /* Be sure to modify the expansion bit in the selection as well as
+    /* If a rootBox was given, then the expansion is being done in the
-     * the one in the layout in order to keep them consistent.
+     * edit cell, and the selection is being updated to reflect any
+     * changes there, so only handle the selection.  Otherwise, we
+     * have to sync the corresponding cells in the edit def here.
      */
-
+    if ((expandType & DB_EXPAND_MASK) == DB_EXPAND)
-    if (DBDescendSubcell(use, mask))
     {
-	DBExpand(selUse, mask, FALSE);
+	/* Be sure to modify the expansion bit in the selection as well as
-	DBExpand(use, mask, FALSE);
+	 * the one in the layout in order to keep them consistent.
-	DBWAreaChanged(use->cu_parent, &use->cu_bbox, mask,
+	 */
-	    (TileTypeBitMask *) NULL);
+	DBExpand(selUse, mask, DB_EXPAND);
+	if (!rootBox)
+	{
+	    DBExpand(use, mask, DB_EXPAND);
+	    if (use->cu_parent == NULL)
+		DBWAreaChanged(use->cu_def, &use->cu_bbox, mask, &DBAllButSpaceBits);
+	    else 
+		DBWAreaChanged(use->cu_parent, &use->cu_bbox, mask, &DBAllButSpaceBits);
+	}
     }
-    else
+    else if ((expandType & DB_EXPAND_MASK) == DB_UNEXPAND)
     {
-	DBExpand(selUse, mask, TRUE);
+	/* Don't change expansion status of root cell:  screws up
-	DBExpand(use, mask, TRUE);
+	 * DBWAreaChanged (need to always have at least top-level
-	DBWAreaChanged(use->cu_parent, &use->cu_bbox, mask, &DBAllButSpaceBits);
+	 * cell be expanded).
+	 */
+
+	if ((use->cu_parent == NULL) && !rootBox)
+	{
+	    TxError("Can't unexpand root cell of window.\n");
+	    return 0;
+	}
+
+	if (use->cu_parent != NULL)
+	{
+	    /* Be sure to modify the expansion bit in the selection as well as
+	     * the one in the layout in order to keep them consistent.
+	     */
+	    DBExpand(selUse, mask, DB_UNEXPAND);
+	    if (!rootBox)
+	    {
+		DBExpand(use, mask, DB_UNEXPAND);
+		DBWAreaChanged(use->cu_parent, &use->cu_bbox, mask,
+			(TileTypeBitMask *) NULL);
+	    }
+	}
+    }
+    else	/* (expandType & DB_EXPAND_MASK) == DB_EXPAND_TOGGLE */
+    {
+	/* Don't change expansion status of root cell:  screws up
+	 * DBWAreaChanged (need to always have at least top-level
+	 * cell be expanded).
+	 */
+
+	if (use->cu_parent == NULL)
+	{
+	    if (!rootBox) TxError("Can't unexpand root cell of window.\n");
+	    return 0;
+	}
+
+	/* Be sure to modify the expansion bit in the selection as well as
+	 * the one in the layout in order to keep them consistent.
+	 */
+
+	if (DBDescendSubcell(selUse, mask))
+	{
+	    DBExpand(selUse, mask, DB_UNEXPAND);
+	    if (!rootBox)
+	    {
+		DBExpand(use, mask, DB_UNEXPAND);
+		DBWAreaChanged(use->cu_parent, &use->cu_bbox, mask,
+			(TileTypeBitMask *) NULL);
+	    }
+	}
+	else
+	{
+	    DBExpand(selUse, mask, DB_EXPAND);
+	    if (!rootBox)
+	    {
+		DBExpand(use, mask, DB_EXPAND);
+		DBWAreaChanged(use->cu_parent, &use->cu_bbox, mask, &DBAllButSpaceBits);
+	    }
+	}
     }
     return 0;
 }

tcltk/drcmgr.tcl

@@ -46,14 +46,14 @@ proc magic::drccallback {command} {
       }
       zoom {
 	 if {$value != {}} {
-	    set snaptype [snap]
+	    set curunits [units]
-	    snap internal
+	    units internal
 	    box values {*}$value
 	    magic::suspendall
 	    magic::findbox zoom
 	    magic::zoom 2
 	    magic::resumeall
-	    snap $snaptype
+	    units {*}$curunits
 	 }
       }
    }

tcltk/texthelper.tcl

@@ -148,6 +148,10 @@ proc magic::make_texthelper { mgrpath } {
 proc magic::analyze_labels {} {
    global typedflt typesticky typeport
 
+   # Ensure units of microns
+   set curunits [units]
+   units microns
+
    # Pick up values from the first entry returned
 
    set tval [lindex [setlabel text] 0]
@@ -157,6 +161,7 @@ proc magic::analyze_labels {} {
    set oval [lindex [setlabel offset] 0]
    set lval [lindex [setlabel layer] 0]
    set kval [lindex [setlabel sticky] 0]
+   set sval [lindex [setlabel size] 0]
    set isport [lindex [port exists] 0]
    if {$isport} {
        set pval [lindex [port index] 0]
@@ -164,14 +169,6 @@ proc magic::analyze_labels {} {
        set pval -1
    }
 
-   # Rescale internal units to microns
-   set sval [lindex [setlabel size] 0]
-   set sscale [cif scale out]
-   set tmp_pre $::tcl_precision
-   set ::tcl_precision 3
-   set sval [expr $sscale * $sval]
-   set ::tcl_precision $tmp_pre
-
    .texthelper.text.tent delete 0 end
    .texthelper.text.tent insert 0 $tval
    set jbtn [string map {NORTH N WEST W SOUTH S EAST E CENTER center} $jval]
@@ -206,6 +203,9 @@ proc magic::analyze_labels {} {
        pack .texthelper.layer.tent -side left -fill x -expand true
        pack .texthelper.layer.btn2 -side left
    }
+
+   # Revert units
+   units {*}$curunits
 }
 
 
@@ -220,6 +220,9 @@ proc magic::change_label {} {
       return
    }
 
+   set curunits [units]
+   units microns
+
    set ltext [.texthelper.text.tent get]
    set lfont [.texthelper.font.btn cget -text]
    set lsize [.texthelper.size.tent get]
@@ -247,13 +250,10 @@ proc magic::change_label {} {
       }
    }
    if {$lsize != ""} {
-      setlabel size ${lsize}um
+      setlabel size $lsize
    }
    if {$loff != ""} {
-      set oldsnap [snap list]
-      snap internal
       setlabel offset [join $loff]
-      snap $oldsnap
    }
    if {$lrot != ""} {
       setlabel rotate $lrot
@@ -274,6 +274,8 @@ proc magic::change_label {} {
          port remove
       }
    }
+  
+   units {*}$curunits
 }
 
 proc magic::make_new_label {} {

tcltk/toolkit.tcl

@@ -10,6 +10,15 @@
 # Revision 2	(names are hashed from properties)
 # March 9, 2021
 # Added spice-to-layout procedure
+# March 4, 2026
+# Changed to make use of new "units" command
+# March 26, 2026
+# Added behavior to handle ideal devices (resistor, capacitor,
+# inductor)
+# April 2, 2026
+# Changed the hash to MurmurHash3, as the existing hash
+# is prone to creating name collisions (rare, but not rare
+# enough).
 #--------------------------------------------------------------
 # Sets up the environment for a toolkit.  The toolkit must
 # supply a namespace that is the "library name".  For each
@@ -118,6 +127,8 @@ magic::tag add select "magic::gencell_update %1"
 
 proc magic::move_forward_by_width {instname} {
     select cell $instname
+    set curunits [units]
+    units internal
     set anum [lindex [array -list count] 1]
     set xpitch [lindex [array -list pitch] 0]
     set bbox [box values]
@@ -125,7 +136,8 @@ proc magic::move_forward_by_width {instname} {
     set posy [lindex $bbox 1]
     set width [expr [lindex $bbox 2] - $posx]
     set posx [expr $posx + $width + $xpitch * $anum]
-    box position ${posx}i ${posy}i
+    box position ${posx} ${posy}
+    units {*}$curunits
     return [lindex $bbox 3]
 }
 
@@ -141,10 +153,13 @@ proc magic::get_and_move_inst {cellname instname {anum 1}} {
     if {$newinst == ""} {return}
     identify $instname
     if {$anum > 1} {array 1 $anum}
+    set curunits [units]
+    units internal
     set bbox [box values]
     set posx [lindex $bbox 2]
     set posy [lindex $bbox 1]
-    box position ${posx}i ${posy}i
+    box position ${posx} ${posy}
+    units {*}$curunits
     return [lindex $bbox 3]
 }
 
@@ -155,11 +170,14 @@ proc magic::get_and_move_inst {cellname instname {anum 1}} {
 #    given layer.  Otherwise, the pin is created on the m1 layer.
 
 proc magic::create_new_pin {pinname portnum {layer m1}} {
-    box size 1um 1um
+    set curunits [units]
+    units microns
+    box size 1 1
     paint $layer
-    label $pinname FreeSans 16 0 0 0 c $layer
+    label $pinname FreeSans 1 0 0 0 c $layer
     port make $portnum
-    box move s 2um
+    box move s 2
+    units {*}$curunits
 }
 
 # generate_layout_add --
@@ -172,6 +190,9 @@ proc magic::create_new_pin {pinname portnum {layer m1}} {
 proc magic::generate_layout_add {subname subpins complist library} {
     global PDKNAMESPACE
 
+    set curunits [units]
+    units internal
+
     # Create a new subcircuit.
     load $subname -quiet
 
@@ -188,7 +209,7 @@ proc magic::generate_layout_add {subname subpins complist library} {
 		    select cell $inst
 		    delete
 		}
-		cellname delete $child
+		cellname delete $child -noprompt
 	    }
 	}
     }
@@ -241,7 +262,7 @@ proc magic::generate_layout_add {subname subpins complist library} {
     box size 0 0
     set posx 0
     set posy [expr {round(3 / [cif scale out])}]
-    box position ${posx}i ${posy}i
+    box position ${posx} ${posy}
 
     # Find all instances in the circuit
     select top cell
@@ -267,8 +288,13 @@ proc magic::generate_layout_add {subname subpins complist library} {
 	set paramlist {}
 
 	# NOTE:  This routine deals with subcircuit calls and devices
-	# with models.  It needs to determine when a device is instantiated
+	# with models.  There are two exceptions, for toolkits which
-	# without a model, and ignore such devices.
+	# wish to implement a way to generate unmodeled capacitors,
+	# resistors, or inductors based on value;  for example, metal
+	# interdigitated capacitors.  For those exceptions, the device
+	# value is recast as a parameter called "value", and the device
+	# is given a model "capacitor", "resistor", or "inductor",
+	# respectively.
 
 	# Parse SPICE line into pins, device name, and parameters.  Make
 	# sure parameters incorporate quoted expressions as {} or ''.
@@ -312,6 +338,23 @@ proc magic::generate_layout_add {subname subpins complist library} {
 	set devtype [lindex $pinlist end]
 	set pinlist [lrange $pinlist 0 end-1]
 
+	# Ideal device check:  "devtype" will start with a digit.
+	# The instname will begin with "c", "r", or "l".
+
+	if {[regexp {^([0-9\.]+.*)} $devtype pval]} {
+	    set comptype [string tolower [string range $instname 0 0]]
+	    if {$comptype == "c"} {
+		lappend paramlist [list value $pval]
+		set devtype capacitor
+	    } elseif {$comptype == "r"} {
+		lappend paramlist [list value $pval]
+		set devtype resistor
+	    } elseif {$comptype == "l"} {
+		lappend paramlist [list value $pval]
+		set devtype inductor
+	    }
+	}
+
 	set mult 1
 	foreach param $paramlist {
 	    set parmname [lindex $param 0]
@@ -323,6 +366,27 @@ proc magic::generate_layout_add {subname subpins complist library} {
 	    }
 	}
 
+	# Check if devtype has routines by looking for ${devtype}_defaults.
+	# If not found, do a case-insensitive check against all devices
+	# before deciding that devtype is a subcircuit and not a device.
+	# If found by case-insensitive check, then change the device name
+	# to the one used in the library.
+
+	if {$library != ""} {
+	    set alldevices [namespace eval ::${library} {info procs}]
+	} else {
+	    set alldevices [namespace eval ::${PDKNAMESPACE} {info procs}]
+	}
+	set devdefault [lsearch $alldevices ${devtype}_defaults]
+	if {$devdefault == -1} {
+	    set devdefault [lsearch -nocase $alldevices ${devtype}_defaults]
+	    if {$devdefault != -1} {
+		set devprocname [lindex $alldevices $devdefault]
+		set devproclist [split $devprocname "_"]
+		set devtype [lindex $devproclist 0]
+	    }
+	}
+
         # devtype is assumed to be in library.  If not, it will attempt to
 	# use 'getcell' on devtype.  Note that this code depends on the
 	# PDK setting varible PDKNAMESPACE.
@@ -374,6 +438,7 @@ proc magic::generate_layout_add {subname subpins complist library} {
 	}
     }
     save $subname
+    units {*}$curunits
 }
 
 #--------------------------------------------------------------
@@ -485,7 +550,7 @@ proc magic::netlist_to_layout {netfile library} {
 	    set subname [lindex $ftokens 1]
 	    set subpins [lrange $ftokens 2 end]
 	    set insub true
-         } elseif {[regexp -nocase {^[xmcrdq]([^ \t]+)[ \t](.*)$} $line \
+         } elseif {[regexp -nocase {^[xmcrldq]([^ \t]+)[ \t](.*)$} $line \
 		    valid instname rest]} {
 	    lappend toplist $line
          } elseif {[regexp -nocase {^[ivbe]([^ \t]+)[ \t](.*)$} $line \
@@ -500,7 +565,7 @@ proc magic::netlist_to_layout {netfile library} {
 	    set subname ""
 	    set subpins ""
 	    set complist {}
-         } elseif {[regexp -nocase {^[xmcrdq]([^ \t]+)[ \t](.*)$} $line \
+         } elseif {[regexp -nocase {^[xmcrldq]([^ \t]+)[ \t](.*)$} $line \
 		    valid instname rest]} {
 	    lappend complist $line
          } elseif {[regexp -nocase {^[ivbe]([^ \t]+)[ \t](.*)$} $line \
@@ -783,11 +848,16 @@ proc magic::gencell_change {instname gencell_type library parameters} {
 	set pdefaults [${library}::${gencell_type}_defaults]
         # Pull user-entered values from dialog
         set parameters [dict merge $pdefaults [magic::gencell_getparams]]
-	set newinstname [.params.title.ient get]
-	if {$newinstname == "(default)"} {set newinstname $instname}
-	if {$newinstname == $instname} {set newinstname $instname}
-	if {[instance list exists $newinstname] != ""} {set newinstname $instname}
     }
+
+    # Attempt to set the new instance name as specified in the dialog.
+    # If the entry is "(default)" or if there is a name collision,
+    # revert the name to the original name.
+
+    set newinstname [.params.title.ient get]
+    if {$newinstname == "(default)"} {set newinstname $instname}
+    if {[instance list exists $newinstname] != ""} {set newinstname $instname}
+
     if {[dict exists $parameters gencell]} {
         # Setting special parameter "gencell" forces the gencell to change type
 	set gencell_type [dict get $parameters gencell]
@@ -805,6 +875,20 @@ proc magic::gencell_change {instname gencell_type library parameters} {
     set gsuffix [magic::get_gencell_hash ${parameters}]
     set gname ${gencell_type}_${gsuffix}
 
+    # Handle instance name changing first.  If no parameters changed, then
+    # we're done.
+    if {$newinstname != $instname} {
+	identify $newinstname
+	# The buttons "Apply" and "Okay" need to be changed for the new
+	# instance name
+	catch {.params.buttons.apply config -command \
+		"magic::gencell_change $newinstname $gencell_type $library {}"}
+	catch {.params.buttons.okay config -command \
+		"magic::gencell_change $newinstname $gencell_type $library {} ;\
+		destroy .params"}
+	set instname $newinstname
+    }
+
     # Guard against instance having been deleted.  Also, if parameters have not
     # changed as evidenced by the cell suffix not changing, then nothing further
     # needs to be done.
@@ -813,8 +897,8 @@ proc magic::gencell_change {instname gencell_type library parameters} {
         return
     }
 
-    set snaptype [snap list]
+    set curunits [units]
-    snap internal
+    units internal
     set savebox [box values]
 
     catch {setpoint 0 0 $Opts(focus)}
@@ -840,31 +924,9 @@ proc magic::gencell_change {instname gencell_type library parameters} {
 	if {$abox != ""} {box values {*}$abox}
 	set newinstname [getcell $gname $orient]
         select cell $newinstname
+	set origname $newinstname
 	expand
 
-	# If the old instance name was not formed from the old cell name,
-	# then keep the old instance name.
-	if {[string first $old_gname $instname] != 0} {
-	    set newinstname $instname
-	}
-
-	if {[cellname list parents $old_gname] == []} {
-	    # If the original cell has no intances left, delete it.  It can
-	    # be regenerated if and when necessary.
-	    cellname delete $old_gname
-	}
-
-    } else {
-        select cell $instname
-	set orient [instance list orientation]
-	set abox [instance list abutment]
-	delete
-
-	# There is no cell of this name, so generate one and instantiate it.
-	if {$abox != ""} {box values {*}$abox}
-	set newinstname [magic::gencell_create $gencell_type $library $parameters $orient]
-	select cell $newinstname
-
 	# If the old instance name was not formed from the old cell name,
 	# then keep the old instance name.
 	if {[string first $old_gname $instname] != 0} {
@@ -878,10 +940,51 @@ proc magic::gencell_change {instname gencell_type library parameters} {
 			"magic::gencell_change $newinstname $gencell_type $library {} ;\
 			destroy .params"}
 	}
+
+	if {[cellname list parents $old_gname] == []} {
+	    # If the original cell has no intances left, delete it.  It can
+	    # be regenerated if and when necessary.
+	    cellname delete $old_gname -noprompt
+	    select cell $origname
+	}
+
+    } else {
+        select cell $instname
+	set orient [instance list orientation]
+	set abox [instance list abutment]
+	delete
+
+	# There is no cell of this name, so generate one and instantiate it.
+	if {$abox != ""} {box values {*}$abox}
+	set newinstname [magic::gencell_create $gencell_type $library $parameters $orient]
+	select cell $newinstname
+	set origname $newinstname
+
+	# If the old instance name was not formed from the old cell name,
+	# then keep the old instance name.
+	if {[string first $old_gname $instname] != 0} {
+	    set newinstname $instname
+	} else {
+	    # The buttons "Apply" and "Okay" need to be changed for the new
+	    # instance name
+	    catch {.params.buttons.apply config -command \
+			"magic::gencell_change $newinstname $gencell_type $library {}"}
+	    catch {.params.buttons.okay config -command \
+			"magic::gencell_change $newinstname $gencell_type $library {} ;\
+			destroy .params"}
+	}
+
+	# If the old cell is not used anywhere, delete it
+	if {[cellname list parents $old_gname] == []} {
+	    # If the original cell has no intances left, delete it.  It can
+	    # be regenerated if and when necessary.
+	    cellname delete $old_gname -noprompt
+	    select cell $origname
+	}
     }
     identify $newinstname
     eval "box values $savebox"
-    snap $snaptype
+    units {*}$curunits
 
     # Update window
     if {$gname != $old_gname} {
@@ -940,8 +1043,8 @@ proc magic::gencell_change_orig {instname gencell_type library parameters} {
         return
     }
 
-    set snaptype [snap list]
+    set curunits [units]
-    snap internal
+    units internal
     set savebox [box values]
 
     catch {setpoint 0 0 $Opts(focus)}
@@ -969,7 +1072,7 @@ proc magic::gencell_change_orig {instname gencell_type library parameters} {
     }
     identify $newinstname
     eval "box values $savebox"
-    snap $snaptype
+    units {*}$curunits
     resumeall
     redraw
 }
@@ -1008,38 +1111,47 @@ proc magic::get_gencell_name {gencell_type} {
 #   gives a result that is repeatable for the same set of
 #   parameter values with a very low probability of a collision.
 #
-#   The hash function is similar to elfhash but reduced from 32
+#   The hash function is murmur3 but reduced from 32 to 30 bits
-#   to 30 bits so that the result can form a 6-character value
+#   so that the result can form a 6-character value in base36
-#   in base32 with all characters being valid for a SPICE subcell
+#   with all characters being valid for a SPICE subcell name
-#   name (e.g., alphanumeric only and case-insensitive).
+#   (e.g., alphanumeric only and case-insensitive).  This
+#   reduces the space from ~4 billion unique suffixes to ~1
+#   billion;  however, even a complex mixed-signal chip design
+#   is unlikely to have more than a few hundred unique parameter
+#   sets for any given device.
+#
+#   Code courtesy of ChatGPT, derived from my implementation.
 #----------------------------------------------------------------
 
 proc magic::get_gencell_hash {parameters} {
-    set hash 0
+    # Canonicalize: sort by key
-    # Apply hash
+    set keys [lsort [dict keys $parameters]]
-    dict for {key value} $parameters {
+
-	foreach s [split $value {}] {
+    # Build input string (values only, but delimited)
-	    set hash [expr {($hash << 4) + [scan $s %c]}]
+    set input ""
-	    set high [expr {$hash & 0x03c0000000}]
+    foreach k $keys {
-	    set hash [expr {$hash ^ ($high >> 30)}]
+	set value [magic::normalize_value [dict get $parameters $k]]
-	    set hash [expr {$hash & (~$high)}]
+        append input "${value};"
-	}
     }
-    # Divide hash up into 5 bit values and convert to base32
+
-    # using letters A-Z less I and O, and digits 2-9.
+    # Compute Murmur hash
+    set hash [magic::murmur3_32 $input]
+
+    # Convert to 6-character base32
     set cvals ""
     for {set i 0} {$i < 6} {incr i} {
-	set oval [expr {($hash >> ($i * 5)) & 0x1f}]
+        set oval [expr {($hash >> ($i * 5)) & 0x1f}]
+
         if {$oval < 8} {
-	    set bval [expr {$oval + 50}]
+            set bval [expr {$oval + 50}]   ;# '2'-'9'
-	} elseif {$oval < 16} {
+        } elseif {$oval < 16} {
-	    set bval [expr {$oval + 57}]
+            set bval [expr {$oval + 57}]   ;# 'A'-'H'
-	} elseif {$oval < 21} {
+        } elseif {$oval < 21} {
-	    set bval [expr {$oval + 58}]
+            set bval [expr {$oval + 58}]   ;# 'J'-'N'
-	} else {
+        } else {
-	    set bval [expr {$oval + 59}]
+            set bval [expr {$oval + 59}]   ;# 'P'-'Z'
-	}
+        }
-	append cvals [binary format c* $bval]
+        append cvals [binary format c* $bval]
     }
     return $cvals
 }
@@ -1092,8 +1204,8 @@ proc magic::gencell_create {gencell_type library parameters {orient 0}} {
 	set parameters [dict remove $parameters gencell]
     }
 
-    set snaptype [snap list]
+    set curunits [units]
-    snap internal
+    units internal
     set savebox [box values]
 
     catch {setpoint 0 0 $Opts(focus)}
@@ -1123,7 +1235,7 @@ proc magic::gencell_create {gencell_type library parameters {orient 0}} {
 	identify $newinstname
 	set instname $newinstname
     }
-    snap $snaptype
+    units {*}$curunits
     resumeall
     redraw
     return $instname
@@ -1163,17 +1275,7 @@ proc magic::add_entry {pname ptext parameters} {
 proc magic::add_check_callbacks {gencell_type library} {
     set wlist [winfo children .params.body.area.edits]
     foreach w $wlist {
-        if {[regexp {\.params\.body\.area\.edits\.(.+)_ent} $w valid pname]} {
+	if {[regexp {\.params\.body\.area\.edits\.(.+)_.+} $w valid pname]} {
-	    # Add callback on enter or focus out
-	    bind $w <Return> \
-			"magic::update_dialog {} $pname $gencell_type $library"
-	    bind $w <FocusOut> \
-			"magic::update_dialog {} $pname $gencell_type $library"
-	}
-        if {[regexp {\.params\.body\.area\.edits\.(.+)_sel} $w valid pname]} {
-	    magic::add_dependency \{\} $gencell_type $library $pname
-	}
-        if {[regexp {\.params\.body\.area\.edits\.(.+)_chk} $w valid pname]} {
 	    magic::add_dependency \{\} $gencell_type $library $pname
 	}
     }
@@ -1192,6 +1294,16 @@ proc magic::add_check_callbacks {gencell_type library} {
 # dictionary.
 #
 # Also handle dependencies on checkboxes and selection lists
+#
+# If dependency callbacks exist, then chain them together.
+# A final default dependency will be added to all entries
+# to run the "check" procedure for the device.  Dependencies
+# that are more targeted get run first.
+#
+# NOTE:  The "check" procedure must be the first in the
+# list, as otherwise, any invalid entry that is corrected
+# by the check callback will have been used to evaluate
+# dependent values.
 #----------------------------------------------------------
 
 proc magic::add_dependency {callback gencell_type library args} {
@@ -1206,21 +1318,28 @@ proc magic::add_dependency {callback gencell_type library args} {
     foreach pname $args {
         if {[lsearch $clist .params.body.area.edits.${pname}_ent] >= 0} {
 	    # Add callback on enter or focus out
-	    bind .params.body.area.edits.${pname}_ent <Return> \
+	    set oldbind [bind .params.body.area.edits.${pname}_ent <Return>]
-			"magic::update_dialog $callback $pname $gencell_type $library"
+	    set newbind "magic::update_dialog $callback $pname $gencell_type $library"
-	    bind .params.body.area.edits.${pname}_ent <FocusOut> \
+	    if {$oldbind != {}} {set newbind "$oldbind ; $newbind"}
-			"magic::update_dialog $callback $pname $gencell_type $library"
+	    bind .params.body.area.edits.${pname}_ent <Return> $newbind
+	    set oldbind [bind .params.body.area.edits.${pname}_ent <FocusOut>]
+	    set newbind "magic::update_dialog $callback $pname $gencell_type $library"
+	    if {$oldbind != {}} {set newbind "$oldbind ; $newbind"}
+	    bind .params.body.area.edits.${pname}_ent <FocusOut> $newbind
 	} elseif {[lsearch $clist .params.body.area.edits.${pname}_chk] >= 0} {
 	    # Add callback on checkbox change state
-	    .params.body.area.edits.${pname}_chk configure -command \
+	    set oldcmd [.params.body.area.edits.${pname}_chk cget -command]
-			"magic::update_dialog $callback $pname $gencell_type $library"
+	    set newcmd "magic::update_dialog $callback $pname $gencell_type $library"
+	    if {$oldcmd != {}} {set newcmd "$oldcmd ; $newcmd"}
+	    .params.body.area.edits.${pname}_chk configure -command $newcmd
 	} elseif {[lsearch $clist .params.body.area.edits.${pname}_sel] >= 0} {
 	    set smenu .params.body.area.edits.${pname}_sel.menu
 	    set sitems [${smenu} index end]
 	    for {set idx 0} {$idx <= $sitems} {incr idx} {
-		set curcommand [${smenu} entrycget $idx -command]
+		set oldcmd [${smenu} entrycget $idx -command]
-		${smenu} entryconfigure $idx -command "$curcommand ; \
+		set newcmd "magic::update_dialog $callback $pname $gencell_type $library"
-		magic::update_dialog $callback $pname $gencell_type $library"
+		if {$oldcmd != {}} {set newcmd "$oldcmd ; $newcmd"}
+		${smenu} entryconfigure $idx -command $newcmd
 	    }
 	}
     }
@@ -1241,13 +1360,13 @@ proc magic::update_dialog {callback pname gencell_type library} {
 	set parameters [dict merge $pdefaults [magic::gencell_getparams]]
     }
 
-    if {$callback != {}} {
-       set parameters [$callback $pname $parameters]
-    }
     if {[catch {set parameters [${library}::${gencell_type}_check $parameters]} \
 		checkerr]} {
 	puts stderr $checkerr
     }
+    if {$callback != {}} {
+       set parameters [$callback $pname $parameters]
+    }
     magic::gencell_setparams $parameters
 }
 
@@ -1611,3 +1730,99 @@ proc magic::gencell_dialog {instname gencell_type library parameters} {
 }
 
 #-------------------------------------------------------------
+# Implementation of murmur3 hash, 32 bits
+# Code courtesy of ChatGPT.
+#-------------------------------------------------------------
+
+proc magic::murmur3_32 {key {seed 0}} {
+    set length [string length $key]
+
+    set c1 0xcc9e2d51
+    set c2 0x1b873593
+
+    set h1 $seed
+
+    # Body (process 4 bytes at a time)
+    set nblocks [expr {$length / 4}]
+    for {set i 0} {$i < $nblocks} {incr i} {
+        binary scan [string range $key [expr {$i*4}] [expr {$i*4+3}]] i k1
+
+        set k1 [expr {($k1 * $c1) & 0xffffffff}]
+        set k1 [expr {(($k1 << 15) | (($k1 & 0xffffffff) >> 17)) & 0xffffffff}]
+        set k1 [expr {($k1 * $c2) & 0xffffffff}]
+
+        set h1 [expr {$h1 ^ $k1}]
+        set h1 [expr {(($h1 << 13) | (($h1 & 0xffffffff) >> 19)) & 0xffffffff}]
+        set h1 [expr {(($h1 * 5) + 0xe6546b64) & 0xffffffff}]
+    }
+
+    # Tail
+    set k1 0
+    set tail_index [expr {$nblocks * 4}]
+    set tail [string range $key $tail_index end]
+    set remaining [string length $tail]
+
+    if {$remaining >= 3} {
+        binary scan [string index $tail 2] c b
+        set k1 [expr {$k1 ^ (($b & 0xff) << 16)}]
+    }
+    if {$remaining >= 2} {
+        binary scan [string index $tail 1] c b
+        set k1 [expr {$k1 ^ (($b & 0xff) << 8)}]
+    }
+    if {$remaining >= 1} {
+        binary scan [string index $tail 0] c b
+        set k1 [expr {$k1 ^ ($b & 0xff)}]
+        set k1 [expr {($k1 * $c1) & 0xffffffff}]
+        set k1 [expr {(($k1 << 15) | (($k1 & 0xffffffff) >> 17)) & 0xffffffff}]
+        set k1 [expr {($k1 * $c2) & 0xffffffff}]
+        set h1 [expr {$h1 ^ $k1}]
+    }
+
+    # Finalization (fmix)
+    set h1 [expr {$h1 ^ $length}]
+    set h1 [expr {$h1 ^ (($h1 & 0xffffffff) >> 16)}]
+    set h1 [expr {($h1 * 0x85ebca6b) & 0xffffffff}]
+    set h1 [expr {$h1 ^ (($h1 & 0xffffffff) >> 13)}]
+    set h1 [expr {($h1 * 0xc2b2ae35) & 0xffffffff}]
+    set h1 [expr {$h1 ^ (($h1 & 0xffffffff) >> 16)}]
+
+    return $h1
+}
+
+#-------------------------------------------------------------
+# Numerical normalization:  Avoid having different suffixes
+# for cells with the same parameter values due to Tcl handling
+# numerical values as strings, which makes "2", "2.0", and "2e0"
+# all separate values.  If hashed on the verbatim values, then
+# the same device with the same parameters can have many
+# different cell names, even though the layout is exactly the
+# same.  Avoid this by detecting when a parameter value is
+# numeric and enforcing a consistent format (fixed precision,
+# four decimal places).
+#
+# Code courtesy of ChatGPT
+#-------------------------------------------------------------
+
+proc magic::normalize_value {value} {
+    # Detect if value is numeric
+    if {[string is double -strict $value]} {
+        set num [expr {double($value)}]
+
+        # Check if effectively integer
+        if {abs($num - round($num)) < 1e-9} {
+            return [format "%d" [expr {int(round($num))}]]
+        }
+
+        # Otherwise, format to fixed precision (3 decimal places)
+        set str [format "%.3f" $num]
+
+        # Strip trailing zeros
+        regsub {\.?0+$} $str "" str
+
+        return $str
+    }
+
+    # Non-numeric: return as-is
+    return $value
+}

tcltk/tools.tcl

@@ -138,7 +138,11 @@ proc magic::pushstack {{name ""}} {
    if {[catch {lindex $editstack end}]} {
       set editstack {}
    }
+   # Protect against changing units by always using internal units
+   set curunits [units]
+   units internal
    lappend editstack [view get]
+   units {*}$curunits
    lappend editstack [cellname list window]
    set ltag [tag load]
    tag load {}
@@ -158,10 +162,11 @@ proc magic::popstack {} {
       tag load {}
       suspendall
       load [lindex $editstack end]
-      set snaptype [snap]
+      # Protect against changing units by always using internal units
-      snap internal
+      set curunits [units]
+      units internal
       view [lindex $editstack end-1]
-      snap $snaptype
+      units {*}$curunits
       catch {magic::cellmanager}
       catch {magic::captions}
       resumeall
@@ -186,8 +191,8 @@ proc magic::clearstack {} {
 
 proc magic::pushbox {{values {}}} {
    global boxstack
-   set snaptype [snap list]
+   set curunits [units]
-   snap internal
+   units internal
    if {[catch {set boxstack}]} {
       set boxstack {}
    }
@@ -196,7 +201,7 @@ proc magic::pushbox {{values {}}} {
    } else {
       lappend boxstack $values
    }
-   snap $snaptype
+   units {*}$curunits
    return
 }
 
@@ -210,8 +215,8 @@ proc magic::pushbox {{values {}}} {
 
 proc magic::popbox {{type values}} {
    global boxstack
-   set snaptype [snap list]
+   set curunits [units]
-   snap internal
+   units internal
    if {[catch {set boxstack}]} {
       error "No stack"
    } elseif {$boxstack == {}} {
@@ -231,7 +236,7 @@ proc magic::popbox {{type values}} {
       }
    }
    set boxstack [lrange $boxstack 0 end-1]
-   snap $snaptype
+   units {*}$curunits
    return $b
 }
 
@@ -355,8 +360,8 @@ proc magic::ruler {{text {}} {orient auto}} {
    set mmx [expr {($llx + $urx) / 2}]
    set mmy [expr {($lly + $ury) / 2}]
 
-   set snapsave [snap]
+   set curunits [units]
-   snap internal
+   units internal
 
    if {$orient == "horizontal"} {
       element add line l1_$Opts(rulers) black $llx $lly $llx $ury
@@ -410,7 +415,7 @@ proc magic::ruler {{text {}} {orient auto}} {
 	  element configure l3_$Opts(rulers) flags arrowbottom
       }
    }
-   snap $snapsave
+   units {*}$curunits
 }
 
 #---------------------------------------------------------------------
@@ -529,8 +534,11 @@ proc magic::enable_tools {} {
    # The user can change these bindings at will by using the
    # "macro" command when the tool is active.
 
+   # NOTE:  Do not name a tool "netlist" because it will get
+   # confused with the "netlist" window.
+
    magic::macro copy wiring
-   magic::macro copy netlist
+   magic::macro copy nettool
    magic::macro copy pick
 
    magic::tool wiring
@@ -544,7 +552,7 @@ proc magic::enable_tools {} {
    macro  Button4 "wire incr width ; wire show"
    macro  Button5 "wire decr width ; wire show"
 
-   magic::tool netlist
+   magic::tool nettool
    macro  Button1          "netlist select"
    macro  Button2          "netlist join"
    macro  Button3          "netlist terminal"
@@ -699,8 +707,8 @@ proc magic::tool {{type next}} {
    if {$type == "next"} {
       switch $Opts(tool) {
 	 box { set type wiring }
-	 wiring { set type netlist }
+	 wiring { set type nettool }
-	 netlist { set type pick }
+	 nettool { set type pick }
 	 pick { set type box }
       }
    }
@@ -756,9 +764,9 @@ proc magic::tool {{type next}} {
 	 set Opts(tool) wiring
 	 cursor 19 	;# sets the cursor
       }
-      netlist {
+      nettool {
 	 puts stdout {Switching to NETLIST tool.}
-	 set Opts(tool) netlist
+	 set Opts(tool) nettool
 	 cursor 18	;# sets the cursor
       }
       pick {

tcltk/wrapper.tcl

@@ -684,7 +684,10 @@ proc magic::cursorview {win} {
       *bypass crosshair ${olstx}um ${olsty}um
    }
 
-   if {[${win} box exists]} {
+   # I do not know why the T/F result gets lost or overridden sometimes
+   set gotbox [${win} box exists]
+   if {$gotbox == {}} {set gotbox false}
+   if {$gotbox} {
       set curunits [${win} units list]
       ${win} units microns noprint
       set dlst [${win} box position]
@@ -825,9 +828,9 @@ proc magic::setscrollvalues {win} {
    global Opts
 
    *bypass logcommands suspend
-   set svalues [${win} view get]
    set curunits [units list]
    units internal noprint
+   set svalues [${win} view get]
    set bvalues [${win} view bbox]
    units {*}$curunits
 

textio/textio.h

@@ -25,6 +25,8 @@
 #ifndef _MAGIC__TEXTIO__TEXTIO_H
 #define _MAGIC__TEXTIO__TEXTIO_H
 
+#include <stdarg.h> /* va_list */
+
 #include "utils/magic.h"
 #include "utils/dqueue.h" /* DQueue */
 

textio/textioInt.h

@@ -42,20 +42,6 @@ typedef struct {
 #define TX_PROMPT	'>'
 #define TX_CMD_PROMPT	":"
 
-/* all of the state associated with a tty terminal */
-#if !defined(SYSV) && !defined(CYGWIN) && !defined(__OpenBSD__) && !defined(EMSCRIPTEN)
-#if defined(HAVE_SYS_IOCTL_COMPAT_H) || defined(HAVE_SGTTY_H)
-#if defined(HAVE_SYS_IOCTL_COMPAT_H)
-#include <sys/ioctl_compat.h> /* replaced sgtty.h */
-#elif defined(HAVE_SGTTY_H)
-#include <sgtty.h>/* legacy - struct sgttyb{} defn */
-#endif
-typedef struct {
-    struct sgttyb tx_i_sgtty;
-    struct tchars tx_i_tchars;
-} txTermState;
-#endif /* HAVE_SYS_IOCTL_COMPAT_H || HAVE_SGTTY_H */
-#endif /* SYSV */
 
 extern bool TxGetInputEvent(bool block, bool returnOnSigWinch);
 

textio/txCommands.c

@@ -39,7 +39,6 @@ static char rcsid[] __attribute__ ((unused)) ="$Header: /usr/cvsroot/magic-8.0/t
 #endif
 
 #include "tcltk/tclmagic.h"
-#include "utils/magsgtty.h"
 #include "utils/magic.h"
 #include "textio/textio.h"
 #include "utils/geometry.h"

textio/txInput.c

@@ -32,14 +32,13 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include <dirent.h>
 
 
-#include "utils/magsgtty.h"
 #include "utils/magic.h"
-#include "utils/magsgtty.h"
 #include "utils/main.h"
 #include "textio/textio.h"
 #include "utils/geometry.h"
 #include "textio/txcommands.h"
 #include "textio/textioInt.h"
+#include "utils/magsgtty.h"	/* txTermState */
 #include "utils/dqueue.h"
 #include "utils/macros.h"
 #include "utils/hash.h"
@@ -1225,36 +1224,21 @@ TxGetLine(
  * ----------------------------------------------------------------------------
  */
 
-#if defined(SYSV) || defined(CYGWIN)
-
-void
-txGetTermState(
-    struct termio *buf)
-{
-    ioctl( fileno( stdin ), TCGETA, buf);
-}
-
-#elif defined (__OpenBSD__) || defined(EMSCRIPTEN)
-
-void
-txGetTermState(
-    struct termios *buf)
-{
-    (void) tcgetattr(fileno(stdin), buf);
-}
-
-#else
-
 void
 txGetTermState(
     txTermState *buf)
 {
+#if defined(HAVE_TERMIOS_H)
+    (void) tcgetattr(fileno(stdin), &buf->termios);
+#elif defined(HAVE_TERMIO_H)
+    ioctl(fileno(stdin), TCGETA, &buf->termio);
+#else /* sgtty */
     ASSERT(TxStdinIsatty, "txGetTermState");
     /* save the current terminal characteristics */
-    (void) ioctl(fileno(stdin), TIOCGETP, (char *) &(buf->tx_i_sgtty) );
+    (void) ioctl(fileno(stdin), TIOCGETP, (char *) &buf->tx_i_sgtty);
-    (void) ioctl(fileno(stdin), TIOCGETC, (char *) &(buf->tx_i_tchars) );
+    (void) ioctl(fileno(stdin), TIOCGETC, (char *) &buf->tx_i_tchars);
+#endif
 }
-#endif /* SYSV */
 
 
 /*
@@ -1273,24 +1257,17 @@ txGetTermState(
 
 void
 txSetTermState(
-#if defined(SYSV) || defined(CYGWIN)
+    txTermState *buf)
-    struct termio *buf
-#elif defined (__OpenBSD__) || defined(EMSCRIPTEN)
-    struct termios *buf
-#else
-    txTermState *buf
-#endif /* SYSV */
-    )
 {
-#if defined(SYSV) || defined(CYGWIN)
+#if defined(HAVE_TERMIOS_H)
-    ioctl( fileno(stdin), TCSETAF, buf );
+    (void) tcsetattr(fileno(stdin), TCSANOW, &buf->termios);
-#elif defined (__OpenBSD__) || defined(EMSCRIPTEN)
+#elif defined(HAVE_TERMIO_H)
-    (void) tcsetattr( fileno(stdin), TCSANOW, buf );
+    ioctl(fileno(stdin), TCSETAF, &buf->termio);
-#else
+#else /* sgtty */
     /* set the current terminal characteristics */
-    (void) ioctl(fileno(stdin), TIOCSETN, (char *) &(buf->tx_i_sgtty) );
+    (void) ioctl(fileno(stdin), TIOCSETN, (char *) &buf->tx_i_sgtty);
-    (void) ioctl(fileno(stdin), TIOCSETC, (char *) &(buf->tx_i_tchars) );
+    (void) ioctl(fileno(stdin), TIOCSETC, (char *) &buf->tx_i_tchars);
-#endif /* SYSV */
+#endif
 }
 
 
@@ -1313,37 +1290,27 @@ txSetTermState(
 
 void
 txInitTermRec(
-#if defined(SYSV) || defined(CYGWIN)
+    txTermState *buf)
-    struct termio *buf
-#elif defined (__OpenBSD__) || defined(EMSCRIPTEN)
-    struct termios *buf
-#else
-    txTermState *buf
-#endif /* SYSV */
-    )
 {
-#if defined(SYSV) || defined(CYGWIN) || defined(__OpenBSD__) || defined(EMSCRIPTEN)
+#if defined(HAVE_TERMIOS_H)
-    buf->c_lflag = ISIG;    /* raw: no echo and no processing, allow signals */
+    buf->termios.c_lflag = ISIG;    /* raw: no echo and no processing, allow signals */
-    buf->c_cc[ VMIN ] = 1;
+    buf->termios.c_cc[ VMIN ] = 1;
-    buf->c_cc[ VTIME ] = 0;
+    buf->termios.c_cc[ VTIME ] = 0;
-#else
+#elif defined(HAVE_TERMIO_H)
+    buf->termio.c_lflag = ISIG;    /* raw: no echo and no processing, allow signals */
+    buf->termio.c_cc[ VMIN ] = 1;
+    buf->termio.c_cc[ VTIME ] = 0;
+#else /* sgtty */
     /* set things up for us, turn off echo, turn on cbreak, no EOF */
     buf->tx_i_sgtty.sg_flags |= CBREAK;
     buf->tx_i_sgtty.sg_flags &= ~ECHO;
     buf->tx_i_tchars.t_eofc = -1;
-
+#endif
-#endif /* SYSV */
 }
 
 
 
-#if defined(SYSV) || defined(CYGWIN)
-struct termio closeTermState;
-#elif defined (__OpenBSD__) || defined(EMSCRIPTEN)
-struct termios closeTermState;
-#else
 static txTermState closeTermState;
-#endif /* SYSV */
 
 static bool haveCloseState = FALSE;
 
@@ -1366,21 +1333,21 @@ static bool haveCloseState = FALSE;
 void
 txSaveTerm(void)
 {
-#if defined(SYSV) || defined(CYGWIN)
+#if defined(HAVE_TERMIOS_H)
-    ioctl( fileno( stdin ), TCGETA, &closeTermState);
+    (void) tcgetattr(fileno(stdin), &closeTermState.termios);
-    txEraseChar = closeTermState.c_cc[VERASE];
+    txEraseChar = closeTermState.termios.c_cc[VERASE];
-    txKillChar =  closeTermState.c_cc[VKILL];
+    txKillChar = closeTermState.termios.c_cc[VKILL];
-    TxEOFChar = closeTermState.c_cc[VEOF];
+    TxEOFChar = closeTermState.termios.c_cc[VEOF];
-    TxInterruptChar = closeTermState.c_cc[VINTR];
+    TxInterruptChar = closeTermState.termios.c_cc[VINTR];
     haveCloseState = TRUE;
-#elif defined (__OpenBSD__) || defined(EMSCRIPTEN)
+#elif defined(HAVE_TERMIO_H)
-    (void) tcgetattr( fileno( stdin ), &closeTermState);
+    ioctl(fileno(stdin), TCGETA, &closeTermState.termio);
-    txEraseChar = closeTermState.c_cc[VERASE];
+    txEraseChar = closeTermState.termio.c_cc[VERASE];
-    txKillChar =  closeTermState.c_cc[VKILL];
+    txKillChar = closeTermState.termio.c_cc[VKILL];
-    TxEOFChar = closeTermState.c_cc[VEOF];
+    TxEOFChar = closeTermState.termio.c_cc[VEOF];
-    TxInterruptChar = closeTermState.c_cc[VINTR];
+    TxInterruptChar = closeTermState.termio.c_cc[VINTR];
     haveCloseState = TRUE;
-#else
+#else /* sgtty */
     struct ltchars lt;
     txGetTermState(&closeTermState);
     (void) ioctl(fileno(stdin), TIOCGLTC, (char *) &lt);
@@ -1393,7 +1360,7 @@ txSaveTerm(void)
     TxEOFChar = closeTermState.tx_i_tchars.t_eofc;
     TxInterruptChar = closeTermState.tx_i_tchars.t_intrc;
     haveCloseState = TRUE;
-#endif /* SYSV */
+#endif
 }
 
 
@@ -1414,13 +1381,7 @@ txSaveTerm(void)
 void
 TxSetTerminal(void)
 {
-#if defined(SYSV) || defined(CYGWIN)
-    struct termio buf;
-#elif defined (__OpenBSD__) || defined(EMSCRIPTEN)
-    struct termios buf;
-#else
     txTermState buf;
-#endif /* SYSV */
 
 #ifdef MAGIC_WRAPPER
     /* If using Tk console, don't mess with the terminal settings;	  */

textio/txMain.c

@@ -26,7 +26,6 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include <string.h>
 #include <unistd.h>
 
-#include "utils/magsgtty.h"
 #include "utils/magic.h"
 #include "textio/textio.h"
 #include "utils/geometry.h"

textio/txOutput.c

@@ -31,7 +31,6 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include <sys/stat.h>
 #include <unistd.h>
 
-#include "utils/magsgtty.h"
 #include "utils/magic.h"
 #include "textio/textio.h"
 #include "utils/geometry.h"

utils/magsgtty.h

@@ -21,44 +21,54 @@
 #ifndef	_MAGIC__UTILS__MAGSGTTY_H
 #define _MAGIC__UTILS__MAGSGTTY_H
 
-/* maybe this can be #ifndef HAVE_TERMIO_H */
-#if !defined(SYSV) && !defined(CYGWIN)
-
-# ifdef	ALPHA
-# undef MAX
-# undef MIN
-# endif
-
-/* unclear what platform requires this OpenBSD/FreeBSD ? */
-# ifndef COMPAT_43TTY
-# define COMPAT_43TTY
-# endif
-
-#ifdef HAVE_SYS_IOCTL_H
-#include <sys/ioctl.h>
-#endif
 
 #if defined(HAVE_TERMIOS_H)
-#include <termios.h>
+ /* In modern times everything has POSIX */
-#elif defined(HAVE_SYS_IOCTL_COMPAT_H)
+ #include <termios.h>
-/* unclear which platform(s) require <sys/ioctl_compat.h> and the structure
+
- *  of this file is such that it will try to include it by default, better
+ #ifdef HAVE_SYS_IOCTL_H
- *  to invert the #if and only select this on the known platforms that need
+  /* Linux glibx 2.x       - present
- *  it so that <termios.h> goes by default, which exists on MacOSX, Linux, etc..
+   * FreeBSD 14.3-RELEASE  - present
- * many possible solutions to make this work by default:
+   * Solaris 11.4          - present
- *   HAVE_SYS_IOCTL_COMPAT_H ?  HAVE_TERMIOS_H ?  !defined(linux) at top (MaxOSX is BSD type)
+   */
- */
+  #include <sys/ioctl.h>
-#include <sys/ioctl_compat.h> /* replaced sgtty.h */
+ #endif
-#elif defined(HAVE_SGTTY_H)
+
-#include <sgtty.h> /* legacy - struct sgttyb{} defn */
+#elif defined(HAVE_TERMIO_H)
+ /* Linux glibx 2.x       - present (just includes termios.h & sys/ioctl.h)
+  * Linux glibc 2.45+     - not present
+  * FreeBSD 14.3-RELEASE  - not present
+  * Solaris 11.4          - present
+  */
+ #include <termio.h>
+#else /* sgtty */
+ #if defined(HAVE_SYS_IOCTL_COMPAT_H)
+  /* Linux glibc2.x        - not present
+   * FreeBSD 14.3-RELEASE  - not present
+   * Solaris 11.4          - not present
+   */
+  #include <sys/ioctl_compat.h> /* replaced sgtty.h */
+ #elif defined(HAVE_SGTTY_H)
+  /* Linux glibc2.x        - present (includes sys/ioctl.h)
+   * FreeBSD 14.3-RELEASE  - not present
+   * Solaris 11.4          - present
+   */
+  #include <sgtty.h> /* legacy - struct sgttyb{} defn */
+ #endif
 #endif
 
-#else
 
-#if defined(HAVE_TERMIO_H)
+/* all of the state associated with a tty terminal */
-#include <termio.h>
+typedef struct {
+#if defined(HAVE_TERMIOS_H)
+    struct termios termios;
+#elif defined(HAVE_TERMIO_H)
+    struct termio termio;
+#else /* sgtty */
+    struct sgttyb tx_i_sgtty;
+    struct tchars tx_i_tchars;
 #endif
+} txTermState;
 
-#endif /* !SYSV && !CYGWIN */
 
 #endif	/* _MAGIC__UTILS__MAGSGTTY_H */

utils/main.c

@@ -38,7 +38,6 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include "utils/main.h"
 #include "utils/magic.h"
 #include "utils/malloc.h"
-#include "utils/magsgtty.h"
 #include "utils/hash.h"
 #include "utils/macros.h"
 #include "textio/textio.h"

utils/signals.c

@@ -33,7 +33,6 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include "tcltk/tclmagic.h"
 #include "utils/main.h"
 #include "utils/magic.h"
-#include "utils/magsgtty.h"
 #include "textio/textio.h"
 #include "utils/geometry.h"
 #include "utils/signals.h"

utils/tech.c

@@ -432,7 +432,8 @@ TechLoad(filename, initmask)
     char suffix[20], line[MAXLINESIZE], *realname;
     char *argv[MAXARGS];
     SectionID mask, badMask;
-    int argc, s;
+    int argc, s, repeatcount = 0;
+    off_t repeatpos;
     bool retval, skip;
     filestack *fstack, *newstack;
     filestack topfile;
@@ -603,6 +604,33 @@ TechLoad(filename, initmask)
     skip = FALSE;
     while ((argc = techGetTokens(line, sizeof line, &fstack, argv)) >= 0)
     {
+	/* Check for end-of-loop */
+	if ((argc == 1) && (!strcmp(argv[0], "endrepeat")))
+	{
+	    if (repeatcount > 0)
+	    {
+		repeatcount--;
+		fseek(fstack->file, repeatpos, SEEK_SET);
+	    }
+	    continue;
+	}
+	/* "repeat <number>" reads the lines until "endrepeat" <number> times */
+	else if ((argc == 2) && (!strcmp(argv[0], "repeat")))
+	{
+	
+	    if (!StrIsInt(argv[1]))
+	    {
+		TechError("Error: \"repeat\" with invalid count %s\n", argv[1]);
+		repeatcount = 0;
+	    }
+	    else
+	    {
+		repeatcount = atoi(argv[1]) - 1;
+		repeatpos = ftell(fstack->file);
+	    }
+	    continue;
+	}
+
 	/* Check for file inclusions (can be nested) */
 	if ((argc > 1) && (!strcmp(argv[0], "include")))
 	{

windows/windCmdAM.c

@@ -1056,6 +1056,7 @@ windDoMacro(w, cmd, interactive)
     bool do_help = FALSE;
     bool do_reverse = FALSE;
     char *searchterm = NULL;
+    char *clientName = NULL;
     macrodef *cMacro;
     HashTable *clienttable;
     HashEntry *h;
@@ -1073,9 +1074,25 @@ windDoMacro(w, cmd, interactive)
 
     argstart = 1;
     if (cmd->tx_argc == 1)
-	wc = DBWclientID;  /* Added by NP 11/15/04 */
+	wc = DBWclientID;	/* Default client */
     else if (cmd->tx_argc > 1)
+    {
 	wc = WindGetClient(cmd->tx_argv[1], TRUE);
+	if (wc != NULL)
+	{
+	    clientName = cmd->tx_argv[1];
+	    argstart++;
+	}
+	else
+	{
+	    /* Check if argument is a known layout button handler */
+	    if (DBWButtonHandlerIndex(cmd->tx_argv[1]) != -1)
+	    {
+		clientName = cmd->tx_argv[1];
+		argstart++;
+	    }
+	}
+    }
 
     while (cmd->tx_argc > argstart)
     {
@@ -1116,6 +1133,15 @@ windDoMacro(w, cmd, interactive)
 			wc = DBWclientID;
 		}
 		MacroCopy(wc, cmd->tx_argv[argstart]);
+
+		/* If tool name did not previously exist, then add
+		 * it to the list of known tool names, so that it
+		 * can be found later by the "macro" command.
+		 */
+		if (DBWButtonHandlerIndex(cmd->tx_argv[argstart]) == -1)
+		    DBWAddButtonHandler(cmd->tx_argv[argstart],	
+				(const cb_database_buttonhandler_t)NULL,
+				0, (const char *)NULL);
 	    }
 	    return;
 	}
@@ -1147,26 +1173,53 @@ windDoMacro(w, cmd, interactive)
 
 	    if (MacroKey(cmd->tx_argv[argstart], &verbose) == 0)
 		if (MacroKey(cmd->tx_argv[argstart + 1], &verbose) != 0)
-		{
-		    wc = 0;
-		    argstart++;
 		    return;
-		}
 	}
     }
-    else
+
-	argstart++;
+    /* If a clientName wasn't given, but wc is DBWclientID, then get
+     * the clientName from the default button handler.
+     */
+
+    if ((clientName == NULL) && (wc == DBWclientID))
+	clientName = DBWGetButtonHandler();
 
     if (cmd->tx_argc == argstart)
     {
-	if (wc == (WindClient)0)
+	if (clientName == NULL)
+	    h = NULL;
+	else
+	    h = HashLookOnly(&MacroClients, (char *)clientName);
+
+	if (h == NULL)
 	{
-	    TxError("No such client.\n");
+#ifdef MAGIC_WRAPPER
+	    Tcl_Obj *lobj;
+	    lobj = Tcl_NewListObj(0, NULL);
+#endif
+	    TxError("Cannot get macro list from current window.\n");
+#ifndef MAGIC_WRAPPER
+	    TxError("List of known macro clients:\n");
+#endif
+	    /* If clientName was not in MacroClients, then what is? */
+	    HashStartSearch(&hs);
+	    while ((h = HashNext(&MacroClients, &hs)) != NULL)
+	    {
+		char *clientName = h->h_key.h_name;
+#ifdef MAGIC_WRAPPER
+		Tcl_ListObjAppendElement(magicinterp, lobj,
+				Tcl_NewStringObj(clientName, -1));
+#else
+		TxError("%s ", clientName);
+#endif
+	    }
+#ifdef MAGIC_WRAPPER
+	    Tcl_SetObjResult(magicinterp, lobj);
+#else
+	    TxError("\n");
+#endif
 	    return;
 	}
-	h = HashLookOnly(&MacroClients, (char *)wc);
-	if (h == NULL)
-	    return;
 	else
 	{
 	    clienttable = (HashTable *)HashGetValue(h);

windows/windCmdSZ.c

@@ -820,22 +820,27 @@ windViewCmd(w, cmd)
 
 	if (!strncmp(cmd->tx_argv[1], "get", 3))
 	{
+	    char *vllx, *vlly, *vurx, *vury;
+
+	    vllx = DBWPrintValue(w->w_surfaceArea.r_xbot, w, TRUE);
+	    vlly = DBWPrintValue(w->w_surfaceArea.r_ybot, w, FALSE);
+	    vurx = DBWPrintValue(w->w_surfaceArea.r_xtop, w, TRUE);
+	    vury = DBWPrintValue(w->w_surfaceArea.r_ytop, w, FALSE);
+
 	    /* NOTE:  The surface area is in screen (pixel) coordinates
 	     * and so does not follow the "units" display type.
 	     */
 #ifndef MAGIC_WRAPPER
-	    TxPrintf("(%d, %d) to (%d, %d)\n",
+	    TxPrintf("(%s, %s) to (%s, %s)\n", vllx, vlly, vurx, vury);
-			w->w_surfaceArea.r_xbot, w->w_surfaceArea.r_ybot,
-			w->w_surfaceArea.r_xtop, w->w_surfaceArea.r_ytop);
 #else
 	    Tcl_ListObjAppendElement(magicinterp, listxy,
-			Tcl_NewIntObj((int)w->w_surfaceArea.r_xbot));
+			Tcl_NewStringObj(vllx, -1));
 	    Tcl_ListObjAppendElement(magicinterp, listxy,
-			Tcl_NewIntObj((int)w->w_surfaceArea.r_ybot));
+			Tcl_NewStringObj(vlly, -1));
 	    Tcl_ListObjAppendElement(magicinterp, listxy,
-			Tcl_NewIntObj((int)w->w_surfaceArea.r_xtop));
+			Tcl_NewStringObj(vurx, -1));
 	    Tcl_ListObjAppendElement(magicinterp, listxy,
-			Tcl_NewIntObj((int)w->w_surfaceArea.r_ytop));
+			Tcl_NewStringObj(vury, -1));
 	    Tcl_SetObjResult(magicinterp, listxy);
 #endif
 	}
@@ -949,7 +954,7 @@ windXviewCmd(w, cmd)
 
     celluse = (CellUse *) (w->w_surfaceID);
     DBExpandAll(celluse, &(celluse->cu_bbox),
-	((DBWclientRec *)w->w_clientData)->dbw_bitmask, FALSE,
+	((DBWclientRec *)w->w_clientData)->dbw_bitmask, DB_UNEXPAND,
 	ViewUnexpandFunc,
 	(ClientData)(pointertype) (((DBWclientRec *)w->w_clientData)->dbw_bitmask));