Fixed an issue with the connectivity stack which does not change

"lasttop" after a new heap has been allocated and "top" is reset.
This is a minor issue, as even random data at the top of the
newly allocated heap is vanishingly unlikely to make a match,
but valgrind caught it as a use of unallocated memory, and it
should be fixed.

.github/workflows/main-wasm.yml

@@ -1,16 +1,11 @@
 name: CI-wasm
 
 # Builds the Magic WebAssembly target on every push and pull request.
-# On version tags (v*), additionally publishes magic-vlsi-wasm to GitHub
+# When the VERSION file changes on the default branch, the package is
-# Packages (npm.pkg.github.com).
+# additionally published to GitHub Packages (npm.pkg.github.com) as
-#
+# @<owner>/magic-vlsi-wasm — no manual tag or token required.
-# The primary goal of this workflow is to always build a WASM version and
+# Tim Edwards updates VERSION to trigger a new release; the scope resolves
-# verify it against the example test suite. Publishing to a package repo is
+# automatically to the repo owner, so forks publish under their own namespace.
-# an optional, tag-gated extension of the same pipeline.
-#
-# Publishing to GitHub Packages first allows testing and evaluation before a
-# wider release to the public npm registry. Consumers can install from there
-# via npm with an appropriate .npmrc pointing at npm.pkg.github.com.
 #
 # WASM is architecture-independent — built once on x86-64, usable everywhere.
 
@@ -34,12 +29,18 @@ on:
 env:
   FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
 
+permissions:
+  contents: read
+  packages: write
+
 jobs:
   build-wasm:
     runs-on: ubuntu-latest
 
     steps:
       - uses: actions/checkout@v5
+        with:
+          fetch-depth: 2
 
       - name: Set up Node.js
         uses: actions/setup-node@v5
@@ -111,15 +112,20 @@ jobs:
             esac
           done
 
-      - name: Set package version
+      - name: Set package version and scope
         run: |
           base=$(cat VERSION)                              # e.g. 8.3.637
           date=$(git show -s --format=%cs | tr -d '-')    # e.g. 20260414
           hash=$(git show -s --format=%h)                 # e.g. d157eea
-          # npm requires semver; use pre-release syntax as the closest equivalent
-          # to the AppImage form 8.3.637~20260414~d157eea
           VERSION="${base}-${date}.${hash}"
+          # Scope the package to the repo owner so it lands in the right
+          # GitHub Packages namespace regardless of who hosts the repo.
+          # e.g. @rtimothyedwards/magic-vlsi-wasm on Tim's repo,
+          #      @intubun/magic-vlsi-wasm on a fork.
+          SCOPED_NAME="@${{ github.repository_owner }}/magic-vlsi-wasm"
           cd npm
+          npm pkg set name="$SCOPED_NAME"
+          npm pkg set publishConfig.registry="https://npm.pkg.github.com"
           npm version "$VERSION" --no-git-tag-version
 
       - name: Pack
@@ -131,8 +137,24 @@ jobs:
           name: magic-vlsi-wasm-npm
           path: npm/*.tgz
 
+      - name: Check if VERSION changed
+        id: version_changed
+        if: github.event_name == 'push'
+        run: |
+          if echo "${{ github.ref }}" | grep -q '^refs/tags/'; then
+            echo "changed=true" >> $GITHUB_OUTPUT
+          elif [ "${{ github.ref }}" = "refs/heads/${{ github.event.repository.default_branch }}" ]; then
+            if git diff --name-only HEAD~1 HEAD 2>/dev/null | grep -q '^VERSION$'; then
+              echo "changed=true" >> $GITHUB_OUTPUT
+            else
+              echo "changed=false" >> $GITHUB_OUTPUT
+            fi
+          else
+            echo "changed=false" >> $GITHUB_OUTPUT
+          fi
+
       - name: Publish to GitHub Packages
-        if: startsWith(github.ref, 'refs/tags/v') && github.event.inputs.dry_run != 'true'
+        if: steps.version_changed.outputs.changed == 'true' && github.event.inputs.dry_run != 'true'
         run: cd npm && npm publish
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

VERSION

@@ -1 +1 @@
-8.3.641
+8.3.656

cif/CIFgen.c

@@ -4117,7 +4117,7 @@ cifSrTiles(
  *	one or more times for the planes being used in processing
  *	where the CIF search should be conducted over "area" scaled
  *	to CIF units, rather than the entire plane.  Currently used 
- *	only for operator CIFOP_INTERACT.
+ *	only for operators CIFOP_INTERACT and CIFOP_TAGGED.
  *
  * Results:
  *	Returns the value returned by the function.
@@ -5681,7 +5681,7 @@ CIFGenLayer(
 
 		for (label = cellDef->cd_labels; label; label = label->lab_next)
 		    if (!strcmp(label->lab_text, text))
-			cifSrTiles(op, &label->lab_rect, cellDef, temps,
+			cifSrTiles2(op, &label->lab_rect, cellDef, temps,
 				cifBloatAllFunc, (ClientData)&bls);
 
 	        /* Reset marked tiles */

commands/CmdE.c

@@ -1096,7 +1096,7 @@ CmdExtract(
 	"lumped			estimate lumped resistance",
 	"labelcheck		check for connections through sticky labels",
 	"aliases		output all net name aliases",
-	"unique			ensure unique node names during extraction",
+	"unique	 [notopports]	ensure unique node names during extraction",
 	"resistance		extract resistance (same as \"do extresist\")",
 	NULL
     };
@@ -1403,6 +1403,7 @@ CmdExtract(
 		TxPrintf("%s label check\n", OPTSET(EXT_DOLABELCHECK));
 		TxPrintf("%s aliases\n", OPTSET(EXT_DOALIASES));
 		TxPrintf("%s unique\n", OPTSET(EXT_DOUNIQUE));
+		TxPrintf("%s unique notopports\n", OPTSET(EXT_DOUNIQNOTOPPORTS));
 		TxPrintf("%s resistance (extresist)\n", OPTSET(EXT_DOEXTRESIST));
 		return;
 #undef	OPTSET
@@ -1433,9 +1434,19 @@ CmdExtract(
 		case DORESISTANCE:	option = EXT_DORESISTANCE; break;
 		case DOLABELCHECK:	option = EXT_DOLABELCHECK; break;
 		case DOALIASES:		option = EXT_DOALIASES; break;
-		case DOUNIQUE:		option = EXT_DOUNIQUE; break;
 		case DOEXTRESIST:
 		case DOEXTRESIST2:	option = EXT_DOEXTRESIST; break;
+		case DOUNIQUE:
+		    if (argc == 4)
+		    {
+			if (!strncmp(argv[3], "notop", 5))
+			    option = EXT_DOUNIQNOTOPPORTS | EXT_DOUNIQUE;
+			else
+			    TxError("Usage:  extract do unique [notopports]\n");
+		    }
+		    else
+			option = EXT_DOUNIQUE;
+		    break;
 		case DOLOCAL:
 		    /* "extract do local" and "extract no local" are kept for
 		     * backwards compatibility, but now effectively implement

commands/CmdLQ.c

@@ -2324,7 +2324,7 @@ CmdDoProperty(
     TxCommand *cmd,
     int argstart)
 {
-    PropertyRecord *proprec;
+    PropertyRecord *proprec = NULL;
     char *value;
     bool propfound, dolist;
     int proptype, proplen, propvalue, i;
@@ -2662,14 +2662,6 @@ CmdDoProperty(
 		     * 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'; )
 		    {
@@ -2681,12 +2673,20 @@ CmdDoProperty(
 			}
 		    }
 		    if (proplen > 0)
+		    {
+			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;
+		    }
 
 		    /* Second pass */
 		    value = cmd->tx_argv[argstart + 1];

commands/CmdRS.c

@@ -635,10 +635,21 @@ cmdSelectArea(
 	int i;
 	for (i = 0; i < DBNumUserLayers; i++)
 	{
-	    if((TTMaskHasType(&mask, i)) && !(TTMaskHasType(&crec->dbw_visibleLayers, i)))
+	    if ((TTMaskHasType(&mask, i)) &&
+			!(TTMaskHasType(&crec->dbw_visibleLayers, i)))
 		TTMaskClearType(&mask, i);
 	}
+
+	/* Remove L_CELL and L_LABEL if crec->dbw_flags indicates that
+	 * they are not visible in the layout window.
+	 */
+
+	if (!(crec->dbw_flags & DBW_SEELABELS)) TTMaskClearType(&mask, L_LABEL);
+	if (!(crec->dbw_flags & DBW_SEECELLS)) TTMaskClearType(&mask, L_CELL);
     }
+    else if (option == SEL_AREA)
+	TTMaskSetType(&mask, L_LABEL);
+
     SelectArea(&scx, &mask, crec->dbw_bitmask, globmatch);
 }
 
@@ -1027,7 +1038,7 @@ CmdSelect(
 
 	/*--------------------------------------------------------------------
 	 * Select everything under the box, perhaps looking only at
-	 * particular layers, but only if its visible.
+	 * particular layers, but only if it's visible.
 	 *--------------------------------------------------------------------
 	 */
 

database/DBconnect.c

@@ -1037,7 +1037,13 @@ dbcConnectFunc(tile, dinfo, cx)
     if (++csa2->csa2_top == CSA2_LIST_SIZE)
     {
 	/* Reached list size limit---need to push the list and	*/
-	/* start a new one.					*/
+	/* start a new one.  NOTE:  Setting lasttop to -1 means	*/
+	/* that some entries may be duplicated between the	*/
+	/* stacks, which is a small inefficiency.  In theory,	*/
+	/* lasttop could be left as is, then if lasttop > top	*/
+	/* when searching the last 5 entries, pop the stack, do	*/
+	/* the search, and then push the stack again.  But it's	*/
+	/* a lot easier just to be slightly inefficient.	*/
 
 	conSrArea *newlist;
 
@@ -1045,6 +1051,7 @@ dbcConnectFunc(tile, dinfo, cx)
 	StackPush((ClientData)csa2->csa2_list, csa2->csa2_stack);
 	csa2->csa2_list = newlist;
 	csa2->csa2_top = 0;
+	csa2->csa2_lasttop = -1;
     }
 
     csa2->csa2_list[csa2->csa2_top].area = newarea;

database/DBio.c

@@ -2016,8 +2016,8 @@ badTransform:
 	if ((cellDef->cd_file != NULL) && (cellDef->cd_file[0] == '/'))
 	{
 	    char *homedir = getenv("HOME");
-	    if (strncmp(cellDef->cd_file, homedir, strlen(homedir)) ||
+	    if (homedir && (strncmp(cellDef->cd_file, homedir, strlen(homedir)) ||
-			*(cellDef->cd_file + strlen(homedir)) != '/')
+			*(cellDef->cd_file + strlen(homedir)) != '/'))
 	    {
 		char *homeroot = strrchr(homedir, '/');
 		int rootlen = (int)(homeroot - homedir) + 1;
@@ -2060,9 +2060,10 @@ badTransform:
 		if (*pathptr == '~')
 		{
 		    char *homedir = getenv("HOME");
-		    if (!strncmp(subCellDef->cd_file, homedir, strlen(homedir))
+		    if (homedir && (!strncmp(subCellDef->cd_file, homedir,
-			    && (!strcmp(subCellDef->cd_file + strlen(homedir),
+				strlen(homedir)) &&
-			    pathptr + 1)))
+				(!strcmp(subCellDef->cd_file + strlen(homedir),
+				pathptr + 1))))
 			pathOK = TRUE;
 		}
 		else if (!strcmp(cwddir, pathptr)) pathOK = TRUE;
@@ -2254,9 +2255,9 @@ badTransform:
 			/* Check if the path is the same as the current directory */
 
 			char *homedir = getenv("HOME");
-			if (!strncmp(cwddir, homedir, strlen(homedir))
+			if (homedir && (!strncmp(cwddir, homedir, strlen(homedir))
 				&& (!strcmp(cwddir + strlen(homedir),
-				pathptr + 1)))
+				pathptr + 1))))
 			    pathOK = TRUE;
 		    }
 		    else if (!strcmp(cwddir, pathptr)) pathOK = TRUE;

database/database.h.in

@@ -578,6 +578,20 @@ typedef struct extRectList
    struct extRectList *r_next;
 } ExtRectList;
 
+/* Structure similar to the above, but adding a pointer to a cell use ID
+ * and a client data record which can be used to hold a region pointer.
+ */
+
+typedef struct extConnList
+{
+   char *r_useid;		/* Cell Use being connected to */
+   TileType r_type;		/* Connecting tile type in the parent */
+   Rect r_r;			/* Area of connection */
+   ClientData r_upnode;		/* Parent node making the connection */
+   ClientData r_downnode;	/* Child node making the connection */
+   struct extConnList *r_next;	/* Next item in the linked list */
+} ExtConnList;
+
 /* -------------------- Search context information -------------------- */
 
 /* Search contexts are used in hierarchical searches */

doc/html/extract.html

@@ -102,16 +102,17 @@ Circuit netlist extractor
 			but will usually just slow down processing by commands
 			like "ext2spice" that use the .ext file contents, so it
 			is disabled by default.
-		  <DT> <B>unique</B>
+		  <DT> <B>unique</B> [<B>notopports</B>]
 		  <DD> (Added in magic version 8.3.594) This setting replaces
-			the use of the command option "extract unique".  Instead
+			the use of the command option "extract unique" (and
-			of changing labels in the design, unique labels are
+			"extract unique notopports").  Instead of changing labels
-			generated for the duration of the extraction, and then
+			in the design, unique labels are generated for the duration
-			reverted back to the original text.  The "extract unique"
+			of the extraction, and then reverted back to the original
-			command option is maintained for backwards compatibility.
+			text.  The "extract unique" command option is maintained
-			Note the difference:  "extract unique" is a command that
+			for backwards compatibility.  Note the difference:
-			runs immediately, and cannot be undone;
+			"extract unique" is a command that runs immediately, and
-			"extract do unique" is an option setting for "extract".
+			cannot be undone; "extract do unique" is an option setting
+			for "extract".
 		  <DT> <B>resistance</B>
 		  <DD> (Added in magic version 8.3.597) This setting replaces
 			the use of the standalone command "extresist".  The

doc/html/extresist.html

@@ -30,11 +30,30 @@ information.
       <BLOCKQUOTE>
          where <I>option</I> may be one of the following:
 	 <DL>
-	   <DT> <B>tolerance</B> <I>value</I>
-	   <DD> Set the ratio between resistor and transistor tolerance
-		for determining when to insert resistance into a network route.
 	   <DT> <B>all</B>
 	   <DD> Extract all the nets.
+	   <DT> <B>threshold</B> [<I>value</I>]
+	   <DD> With no value given, returns the current lumped resistance
+		threshold used to determine if a network will or will not be
+		analyzed for resistance extraction, in milliohms.  The default
+		<B>threshold</B> value is 10000 milliohms (10 ohms).  If
+		<I>value</I> is given, then set the lumped resistance threshold
+		to <I>value</I> milliohms.
+	   <DT> <B>mindelay</B> [<I>value</I>]
+	   <DD> With no value given, returns the current delay time threshold
+		used to determine if a network will or will not be analyzed for
+		resistance extraction, in picoseconds.  The default
+		<B>mindelay</B> value is 1ps.  If <I>value</I> is given,
+		then set the delay threshold to <I>value</I> picoseconds.
+	   <DT> <B>minres</B> [<I>value</I>]
+	   <DD> With no value given, returns the current absolute resistance
+		threshold used to prune small resistances from a network when
+		simplifying, in milliohms.  The default <B>minres</B> value
+		is 1000 milliohms (1 ohm).  If <I>value</I> is given, then set
+		the absolute resistance threshold to <I>value</I> milliohms.
+		Note that resistances smaller than <I>value</I> may still
+		appear in the output netlist if the algorithm is unable to
+		simplify the network around the resistor.
 	   <DT> <B>simplify</B> [<B>on</B>|<B>off</B>]
 	   <DD> Turn on/off simplification of resistor nets.
 	   <DT> <B>extout</B> [<B>on</B>|<B>off</B>]
@@ -42,7 +61,9 @@ information.
 	   <DT> <B>lumped</B> [<B>on</B>|<B>off</B>]
 	   <DD> Turn on/off writing of updated lumped resistances.
 	   <DT> <B>silent</B> [<B>on</B>|<B>off</B>]
-	   <DD> Turn off/on printing of net statistics.
+	   <DD> Turn off/on printing of nets being processed.
+	   <DT> <B>debug</B> [<B>on</B>|<B>off</B>]
+	   <DD> Turn off/on additional diagnostic information.
 	   <DT> <B>skip</B> <I>mask</I>
 	   <DD> Don't extract types indicated in the comma-separated list <I>mask</I>
 	   <DT> <B>ignore</B> [<I>netname</I>|<B>none</B>]
@@ -69,6 +90,8 @@ information.
 		<TT>.fh</TT> file.  If <I>freq</I> is specified, the file will
 		be customized for <B>fasthenry</B> analysis at the indicated
 		frequency (in Hz).
+	   <DT> <B>tolerance</B> <I>value</I>
+	   <DD> <I>Deprecated!</I>  This option is no longer used by extresist.
 	   <DT> <B>help</B>
 	   <DD> Print help information
 	 </DL>
@@ -79,9 +102,9 @@ information.
    <BLOCKQUOTE>
       The normal flow through layout extraction into a simulation file
       treats routes as nonphysical entities, that is, with infinitesimal
-      impedence through the wires.  Extraction for digital simulation
+      impedence through the wires.  Standard extraction generates "lumped
-      using <B>irsim</B> generates "lumped resistances", a single
+      resistance" values, a single resistance per network node that, along
-      resistance per network node that, along with the node capacitance
+      with the node capacitance
       to substrate, provides an <I>RC</I> time constant to approximately
       model the delay from point to point in the network node.  The
       lumped resistance model is inappropriate for analog (i.e., SPICE)
@@ -96,10 +119,9 @@ information.
 
       Using <B>extresist</B> as a standalone command is a multi-step
       process.  It is first necessary to run <B>extract</B> to get
-      the initial netlist.
+      the initial netlist.  After a <TT>.ext</TT> file has been generated,
-      After a <TT>.ext</TT> file has been generated, the
+      the <B>extresist</B> command may be run.  The output is a file
-      <B>extresist</B> command may be run.  The output is
+      <TT>.res.ext</TT> for each cell in the hierarchy.
-      a file <TT>.res.ext</TT> for each cell in the hierarchy.
       Finally, with the option <B>extresist on</B> set, <B>ext2spice</B>
       will generate the final, detailed simulation file. <P>
 
@@ -110,7 +132,42 @@ information.
       magic version 8.3.597 an option <B>extract do resistance</B>
       that runs the resistance extraction in sequence with the regular
       extraction, producing both the <TT>.ext</TT> and <TT>.res.ext</TT>
-      files.
+      files.  When <B>extract do resistance</B> is used, there is no need
+      to run <B>extresist</B> as a separate command.  However,
+      <B>extresist</B> may be run prior to <B>extract</B> to set the
+      options that affect resistance network extraction, such as
+      <B>extresist threshold</B>, <B>extresist minres</B>, etc. <P>
+
+      As of magic version 8.3.653, the <B>extresist tolerance</B> option
+      is deprecated and has no effect on network resistance extraction.
+      Instead, extraction is controlled by three main options: <P>
+     
+      <B>extresist threshold</B> (value in milliohms) sets a cutoff for
+      considering a network for detailed resistance extraction based on
+      the lumped resistance estimate (see above).  For point-to-point
+      wires, the lumped resistance is approximately equal to the actual
+      wire resistance.  For branching networks, it will generally be an
+      over-estimate.  The default <B>threshold</B> value is set to
+      10 ohms. <P>
+
+      <B>extresist minres</B> (value in milliohms) sets a cutoff for
+      individual resistors in the detailed resistor network.  Resistors
+      below this threshold will get pruned out of the network if the
+      simplification algorithm is able to remove them.  The default
+      <B>minres</B> value is set to 1 ohm. <P>
+
+      <B>extresist mindelay</B> (value in picoseconds) sets a cutoff for
+      considering a network for detailed resistance extraction based on
+      the end-to-end delay calculated from the lumped resistance
+      estimate.  Once the network has been extracted, the <B>mindelay</B>
+      value is again evaluated against a revised calculation of the
+      delay to determine if the extracted detailed network should be
+      output.  The default <B>mindelay<B> value is set to 0, indicating
+      that only the lumped resistance threshold should be used for
+      determining when to extract a detailed resistance network.
+      <B>mindelay</B> may be used in place of <B>threshold</B>, or both
+      may be used together, in which case a network is only extracted
+      if both <B>threshold</B> and <B>mindelay</B> are exceeded. <P>
 
       More details on using <B>extresist</B> can be found in
       <B>magic</B> Tutorial number 8.
@@ -134,6 +191,6 @@ information.
     <TD> <A HREF=commands.html>Return to command index</A>
   </TR>
 </TABLE>
-<P><I>Last updated:</I> October 4, 2021 at 3:32pm <P>
+<P><I>Last updated:</I> May 29, 2026 at 11:33am <P>
 </BODY>
 </HTML>

drc/DRCbasic.c

@@ -830,7 +830,7 @@ drcTile (tile, dinfo, arg)
 		     * an exception area.  Exception rules are ignored if
 		     * the edge is outside an exception area.
 		     */
-		    if (!isinside && (!(cptr->drcc_exception & DRC_EXCEPTION_MASK) == 0))
+		    if (!isinside && ((cptr->drcc_exception & DRC_EXCEPTION_MASK) == 0))
 			continue;
 		    if (isinside && ((cptr->drcc_exception & DRC_EXCEPTION_MASK) != 0))
 			continue;

ext2spice/ext2hier.c

@@ -757,7 +757,7 @@ spcdevHierVisit(
 	case DEV_FET:
 	    if (source == drain)
 	    {
-		if (esFormat == NGSPICE) fprintf(esSpiceF, "$ ");
+		if (esFormat == NGSPICE) fprintf(esSpiceF, "; ");
 		fprintf(esSpiceF, "** SOURCE/DRAIN TIED\n");
 	    }
 	    break;
@@ -765,7 +765,7 @@ spcdevHierVisit(
 	default:
 	    if (gate == source)
 	    {
-		if (esFormat == NGSPICE) fprintf(esSpiceF, "$ ");
+		if (esFormat == NGSPICE) fprintf(esSpiceF, "; ");
 		fprintf(esSpiceF, "** SHORTED DEVICE\n");
 	    }
 	    break;
@@ -1658,7 +1658,7 @@ spcnodeHierVisit(
 	static char ntmp[MAX_STR_SIZE];
 
 	EFHNSprintf(ntmp, hierName);
-	if (esFormat == NGSPICE) fprintf(esSpiceF, " $ ");
+	if (esFormat == NGSPICE) fprintf(esSpiceF, " ; ");
 	fprintf(esSpiceF, "** %s == %s\n", ntmp, nsn);
     }
     cap = cap  / 1000;
@@ -1668,14 +1668,14 @@ spcnodeHierVisit(
 	esSIvalue(esSpiceF, 1.0E-15 * cap);
 	if (!isConnected)
 	{
-	    if (esFormat == NGSPICE) fprintf(esSpiceF, " $");
+	    if (esFormat == NGSPICE) fprintf(esSpiceF, " ;");
 	    fprintf(esSpiceF, " **FLOATING");
 	}
 	fprintf(esSpiceF, "\n");
     }
     if (node->efnode_attrs && !esNoAttrs)
     {
-	if (esFormat == NGSPICE) fprintf(esSpiceF, " $ ");
+	if (esFormat == NGSPICE) fprintf(esSpiceF, " ; ");
 	fprintf(esSpiceF, "**nodeattr %s :",nsn );
 	for (fmt = " %s", ap = node->efnode_attrs; ap; ap = ap->efa_next)
 	{

ext2spice/ext2spice.c

@@ -2817,7 +2817,7 @@ spcdevVisit(
 	case DEV_FET:
 	    if (source == drain)
 	    {
-		if (esFormat == NGSPICE) fprintf(esSpiceF, "$ ");
+		if (esFormat == NGSPICE) fprintf(esSpiceF, "; ");
 		fprintf(esSpiceF, "** SOURCE/DRAIN TIED\n");
 	    }
 	    break;
@@ -2825,7 +2825,7 @@ spcdevVisit(
 	default:
 	    if (gate == source)
 	    {
-		if (esFormat == NGSPICE) fprintf(esSpiceF, "$ ");
+		if (esFormat == NGSPICE) fprintf(esSpiceF, "; ");
 		fprintf(esSpiceF, "** SHORTED DEVICE\n");
 	    }
 	    break;
@@ -4111,7 +4111,7 @@ spcnodeVisit(
 	static char ntmp[MAX_STR_SIZE];
 
 	EFHNSprintf(ntmp, hierName);
-	if (esFormat == NGSPICE) fprintf(esSpiceF, "$ ");
+	if (esFormat == NGSPICE) fprintf(esSpiceF, "; ");
 	fprintf(esSpiceF, "** %s == %s\n", ntmp, nsn);
     }
     cap = cap  / 1000;
@@ -4121,14 +4121,14 @@ spcnodeVisit(
 	esSIvalue(esSpiceF, 1.0E-15 * cap);
 	if (!isConnected)
 	{
-	    if (esFormat == NGSPICE) fprintf(esSpiceF, " $");
+	    if (esFormat == NGSPICE) fprintf(esSpiceF, " ;");
 	    fprintf(esSpiceF, " **FLOATING");
 	}
 	fprintf(esSpiceF, "\n");
     }
     if (node->efnode_attrs && !esNoAttrs)
     {
-	if (esFormat == NGSPICE) fprintf(esSpiceF, " $ ");
+	if (esFormat == NGSPICE) fprintf(esSpiceF, " ; ");
 	fprintf(esSpiceF, "**nodeattr %s :",nsn );
 	for (fmt = " %s", ap = node->efnode_attrs; ap; ap = ap->efa_next)
 	{

extflat/EFbuild.c

@@ -706,6 +706,11 @@ efBuildEquiv(def, nodeName1, nodeName2, resist, isspice)
 			dev->dev_terms[n].dterm_node =
 				(nn1->efnn_node == NULL) ?
 				nn2->efnn_node : nn1->efnn_node;
+
+		/* Also check the substrate terminal */
+		if (dev->dev_subsnode == lostnode)
+		    dev->dev_subsnode = (nn1->efnn_node == NULL) ?
+				nn2->efnn_node : nn1->efnn_node;
 	    }
 
 	    /* If a node has been merged away, make sure that its name	*/
@@ -1618,12 +1623,128 @@ efConnectionFreeLinkedList(Connection *conn)
     }
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * efConnPointFreeLinkedList --
+ *
+ * Release memory for linked-list of ConnectionPoint* based on internal
+ *  list at ConnectionPoint->conn_next.  'connpt' argument must be non-NULL.
+ *
+ * Results:
+ *	Deallocates linked-list of ConnectionPoint* starting at 'connpt'
+ *
+ * Side effects:
+ *	Deallocates one or more connection point record(s).
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+void
+efConnPointFreeLinkedList(ConnectionPoint *connpt)
+{
+    while (connpt)
+    {
+	ConnectionPoint *next = connpt->conn_next;
+	if (connpt->conn_name != NULL)
+	    freeMagic(connpt->conn_name);
+	freeMagic(connpt);
+	connpt = next;
+    }
+}
+
 /*
  * ----------------------------------------------------------------------------
  *
  * efBuildConnect --
  *
  * Process a "connect" line from a .ext file.
+ * Creates a record of the area and type of the connection.  Since the
+ * extraction at the point of finding connections no longer knows what
+ * net in the celldef (if any) is part of the connection, only the
+ * location and type is preserved, and the cell being connected has to
+ * be recovered by a search on the celldef's layout.  These records are
+ * used only by "extresist".
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Allocates a new connection port record for extresist, and prepends
+ *	it to the list for def.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+void
+efBuildConnect(def, llx, lly, urx, ury, layerName, upnodeName, downnodeName)
+    Def *def;
+    int llx, lly, urx, ury;
+    char *layerName;
+    char *upnodeName;
+    char *downnodeName;
+{
+    int tnew;
+    ConnectionPoint *connpt;
+    HashEntry *he;
+    Use *subuse;
+    char *hierptr, *qptr, *useid;
+
+    /* Can't do anything without a node name to connect to */
+    if (!strcmp(downnodeName, "\"None\"")) return;
+
+    /* "downnodeName" should be hierarchical;  stop at the first hierarchical
+     * divider and use the prefix to find the use being connected to.
+     * NOTE:  This will require dealing with connections that are more than
+     * one hierarchical level deep (to be done).
+     */
+    useid = downnodeName;
+    if (*useid == '"') useid++;
+    hierptr = strchr(useid, '/');
+    if (hierptr != NULL) *hierptr = '\0';
+    qptr = strrchr(useid, '"');
+    if (qptr != NULL) *qptr = '\0';
+
+    if (layerName)
+	tnew = efBuildAddStr(EFLayerNames, &EFLayerNumNames, MAXTYPES, layerName);
+    else
+	tnew = 0;
+
+    connpt = (ConnectionPoint *)mallocMagic(sizeof(ConnectionPoint));
+
+    he = HashFind(&def->def_uses, useid);
+    subuse = (Use *)HashGetValue(he);
+    connpt->conn_use = subuse;
+
+    connpt->conn_r.r_xbot = llx;
+    connpt->conn_r.r_ybot = lly;
+    connpt->conn_r.r_xtop = urx;
+    connpt->conn_r.r_ytop = ury;
+    connpt->conn_type = tnew;
+    if (!strcmp(upnodeName, "\"None\""))
+	connpt->conn_name = (char *)NULL;
+    else
+    {
+	if (*upnodeName == '"') upnodeName++;
+	connpt->conn_name = StrDup((char **)NULL, upnodeName);
+	if ((qptr = strrchr(connpt->conn_name, '"')) != NULL) *qptr = '\0';
+    }
+
+    /* To do:  Add "downnodeName" to the ConnectionPoint structure.  This
+     * may not be necessary, as it is only being used by "extresist" which
+     * is not using the extflat parser.
+     */ 
+
+    connpt->conn_next = def->def_connpts;
+    def->def_connpts = connpt;
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * efBuildMerge --
+ *
+ * Process a "merge" line from a .ext file.
  * Creates a connection record for the names 'nodeName1' and
  * 'nodeName2'.
  *
@@ -1638,7 +1759,7 @@ efConnectionFreeLinkedList(Connection *conn)
  */
 
 void
-efBuildConnect(def, nodeName1, nodeName2, deltaC, av, ac)
+efBuildMerge(def, nodeName1, nodeName2, deltaC, av, ac)
     Def *def;		/* Def to which this connection is to be added */
     char *nodeName1;	/* Name of first node in connection */
     char *nodeName2;	/* Name of other node in connection */

extflat/EFdef.c

@@ -122,6 +122,7 @@ EFDone(func)
 	efConnectionFreeLinkedList(def->def_conns);
 	efConnectionFreeLinkedList(def->def_caps);
 	efConnectionFreeLinkedList(def->def_resistors);
+	efConnPointFreeLinkedList(def->def_connpts);
 
 	free_magic1_t mm1 = freeMagic1_init();
 	for (kill = def->def_kills; kill; kill = kill->kill_next)
@@ -248,6 +249,7 @@ efDefNew(name)
     newdef->def_conns = (Connection *) NULL;
     newdef->def_caps = (Connection *) NULL;
     newdef->def_resistors = (Connection *) NULL;
+    newdef->def_connpts = (ConnectionPoint *) NULL;
     newdef->def_kills = (Kill *) NULL;
 
     /* Initialize circular list of nodes */

extflat/EFint.h

@@ -145,6 +145,8 @@ typedef struct conn
 #define conn_res	conn_value.conn_val_res
 #define conn_cap	conn_value.conn_val_cap
 
+typedef struct connpoint ConnectionPoint;
+
 /* -------------------------- Defs and uses --------------------------- */
 
 /* A Def exists for each .ext file */
@@ -162,6 +164,7 @@ typedef struct def
 	/* The following are all NULL-terminated lists */
 
     Connection	*def_conns;	/* Hierarchical connections/adjustments */
+    ConnectionPoint *def_connpts; /* Position of hierarchical connections */
     Connection	*def_caps;	/* Two-terminal capacitors */
     Connection	*def_resistors;	/* Two-terminal resistors */
     Kill	*def_kills;	/* Used to modify hierarchical structure
@@ -206,6 +209,17 @@ typedef struct use
 
 #define	IsArray(u)  ((u)->use_xlo!=(u)->use_xhi || (u)->use_ylo!=(u)->use_yhi)
 
+/* Connection point structure (used by "extresist") */
+
+typedef struct connpoint
+{
+    Use		*conn_use;		/* Use being connected to */
+    Rect	conn_r;			/* Area, edge, or point of connection */
+    int		conn_type;		/* A tile type at the connection */
+    char	*conn_name;		/* Top level name of node, or NULL */
+    struct connpoint *conn_next;	/* Next connection point in list */
+} ConnectionPoint;
+
 /* -------------------------------------------------------------------- */
 
 /* Structure passed down during hierarchical searching */
@@ -307,7 +321,9 @@ extern void CapHashSetValue();
 extern DevParam *efGetDeviceParams();
 extern void efBuildNode();
 extern void efConnectionFreeLinkedList(Connection *conn);
+extern void efConnPointFreeLinkedList(ConnectionPoint *conn);
 extern void efBuildConnect();
+extern void efBuildMerge();
 extern void efBuildResistor();
 extern void efBuildCap();
 extern HierContext *EFFlatBuildOneLevel();

extflat/EFread.c

@@ -275,15 +275,11 @@ readfile:
 		efBuildCap(def, argv[1], argv[2], (double) cap);
 		break;
 
-	    /* subcap node capacitance */
+	    /* connect useid llx lly urx ury type "node" ... */
-	    case SUBCAP:
+	    case CONNECT:
-		cap = cscale*atoCap(argv[2]);
+		efBuildConnect(def, atoi(argv[1]), atoi(argv[2]),
-		efAdjustSubCap(def, argv[1], cap);
+				atoi(argv[3]), atoi(argv[4]), argv[5],
-		break;
+				argv[6], argv[7]);
-
-	    /* equiv node1 node2 */
-	    case EQUIV:
-		efBuildEquiv(def, argv[1], argv[2], resist, isspice);
 		break;
 
 	    /* replaces "fet" (below) */
@@ -344,6 +340,11 @@ readfile:
 		}
 		break;
 
+	    /* equiv node1 node2 */
+	    case EQUIV:
+		efBuildEquiv(def, argv[1], argv[2], resist, isspice);
+		break;
+
 	    /* for backwards compatibility */
 	    /* fet type xlo ylo xhi yhi area perim substrate GATE T1 T2 ... */
 	    case FET:
@@ -373,7 +374,7 @@ readfile:
 		*/
 
 		cap = (argc > 3) ? atoCap(argv[3]) * cscale : 0;
-		efBuildConnect(def, argv[1], argv[2], (double)cap, &argv[4], argc - 4);
+		efBuildMerge(def, argv[1], argv[2], (double)cap, &argv[4], argc - 4);
 		break;
 
 	    /* node name R C x y layer a1 p1 a2 p2 ... [ attrs ] */
@@ -449,6 +450,12 @@ resistChanged:
 		    }
 		break;
 
+	    /* subcap node capacitance */
+	    case SUBCAP:
+		cap = cscale*atoCap(argv[2]);
+		efAdjustSubCap(def, argv[1], cap);
+		break;
+
 	    /* use def use-id T0 .. T5 */
 	    case USE:
 		efBuildUse(def, argv[1], argv[2],

extflat/extparse.h

@@ -25,9 +25,9 @@
  */
 typedef enum
 {
-    ABSTRACT, ADJUST, ATTR, CAP, DEVICE, DIST, EQUIV, FET, KILLNODE, MERGE,
+    ABSTRACT, ADJUST, ATTR, CAP, CONNECT, DEVICE, DIST, EQUIV, FET, KILLNODE,
-    NODE, PARAMETERS, PORT, PRIMITIVE, RESISTOR, RESISTCLASS, RNODE, SCALE,
+    MERGE, NODE, PARAMETERS, PORT, PRIMITIVE, RESISTOR, RESISTCLASS, RNODE,
-    SUBCAP, SUBSTRATE, TECH, TIMESTAMP, USE, VERSION, EXT_STYLE
+    SCALE, SUBCAP, SUBSTRATE, TECH, TIMESTAMP, USE, VERSION, EXT_STYLE
 } Key;
 
 static const struct
@@ -42,6 +42,7 @@ keyTable[] =
     {"adjust",		ADJUST,		4},
     {"attr",		ATTR,		8},
     {"cap",		CAP,		4},
+    {"connect",		CONNECT,	7},
     {"device",		DEVICE,		11},	/* effectively replaces "fet" */
     {"distance",	DIST,		4},
     {"equiv",		EQUIV,		3},

extract/ExtBasic.c

@@ -629,6 +629,8 @@ extSetResist(reg)
 
     for (n = 0; n < ExtCurStyle->exts_numResistClasses; n++)
     {
+	ResValue resnew, restot;
+
 	reg->nreg_pa[n].pa_area = area = extResistArea[n];
 	reg->nreg_pa[n].pa_perim = perim = extResistPerim[n];
 	if (area > 0 && perim > 0)
@@ -639,8 +641,15 @@ extSetResist(reg)
 	    if (v < 0) s = 0; else s = sqrt(v);
 
 	    fperim = (float) perim;
-	    reg->nreg_resist += (fperim + s) / (fperim - s)
+	    resnew = (fperim + s) / (fperim - s) *
-				    * ExtCurStyle->exts_resistByResistClass[n];
+		    ExtCurStyle->exts_resistByResistClass[n];
+	    restot = reg->nreg_resist + resnew;
+
+	    /* Check for integer overflow.  There is no point in trying
+	     * to accommodate huge resistance values for an estimate.
+	     * The value just saturates at the maximum integer value.
+	     */
+	    if (restot > 0) reg->nreg_resist = restot;
 	}
 
 	/* Reset for the next pass */
@@ -722,7 +731,8 @@ extOutputNodes(nodeList, outFile)
 	/* Check if this node is the substrate */
 	if (reg == glob_subsnode)
 	{
-	    fprintf(outFile, "substrate \"%s\" 0 0", text);
+	    intR = (reg->nreg_resist + rround) / ExtCurStyle->exts_resistScale;
+	    fprintf(outFile, "substrate \"%s\" %d 0", text, intR);
 	}
 	else
 	{
@@ -1110,7 +1120,7 @@ ExtSortTerminals(tran, ll)
     do
     {
 	changed = 0;
-	for( nsd = 0; nsd < tran->tr_nterm-1; nsd++ )
+	for (nsd = 0; nsd < tran->tr_nterm-1; nsd++)
 	{
 	    p1 = &(tran->tr_termpos[nsd]);
 	    p2 = &(tran->tr_termpos[nsd+1]);
@@ -1155,14 +1165,17 @@ ExtSortTerminals(tran, ll)
             *  but S,D attributes are not that common so it should not matter
             * that much -- Stefanos 5/96 */
 
-            for ( lp = ll ; lp ; lp = lp->ll_next )
+            for (lp = ll; lp; lp = lp->ll_next)
-		if ( lp->ll_attr == nsd ) lp->ll_attr = LL_SORTATTR ;
+		if (lp->ll_attr == nsd)
-		else if ( lp->ll_attr == nsd+1 ) lp->ll_attr = nsd ;
+		    lp->ll_attr = LL_SORTATTR;
-            for ( lp = ll ; lp ; lp = lp->ll_next )
+		else if (lp->ll_attr == nsd + 1)
-		 if ( lp->ll_attr == LL_SORTATTR ) lp->ll_attr = nsd+1;
+		    lp->ll_attr = nsd;
+            for (lp = ll; lp; lp = lp->ll_next)
+		if (lp->ll_attr == LL_SORTATTR)
+		    lp->ll_attr = nsd + 1;
 	}
      }
-     while( changed );
+     while (changed);
 }
 
 /*

extract/ExtCell.c

@@ -76,18 +76,19 @@ void extHeader();
  */
 
 Plane *
-ExtCell(def, outName, doLength)
+ExtCell(def, outName, isTop)
     CellDef *def;	/* Cell being extracted */
     char *outName;	/* Name of output file; if NULL, derive from def name */
-    bool doLength;	/* If TRUE, extract pathlengths from drivers to
+    bool isTop;		/* If TRUE, cell is the top level cell */
-			 * receivers (the names are stored in ExtLength.c).
-			 * Should only be TRUE for the root cell in a
-			 * hierarchy.
-			 */
 {
     char *filename;
     FILE *f = NULL;
     Plane *savePlane;
+    bool noextract;
+
+    /* If marked abstract, then don't extract the cell */
+    DBPropGet(def, "noextract", &noextract);
+    if (noextract) return extPrepSubstrate(def);
 
     /* Incremental extraction:  If the cell is marked for no extraction,
      * then just prepare the substrate plane and return it to the caller.
@@ -111,7 +112,7 @@ ExtCell(def, outName, doLength)
     }
 
     extNumErrors = extNumWarnings = 0;
-    savePlane = extCellFile(def, f, doLength);
+    savePlane = extCellFile(def, f, isTop);
     if (f != NULL) fclose(f);
 
     if (extNumErrors > 0 || extNumWarnings > 0)
@@ -471,13 +472,10 @@ ExtRevertSubstrate(def, savePlane)
  */
 
 Plane *
-extCellFile(def, f, doLength)
+extCellFile(def, f, isTop)
     CellDef *def;	/* Def to be extracted */
     FILE *f;		/* Output to this file */
-    bool doLength;	/* TRUE if we should extract driver-receiver path
+    bool isTop;		/* TRUE if the cell is the top level cell */
-			 * length information for this cell (see ExtCell
-			 * for more details).
-			 */
 {
     NodeRegion *reg;
     Plane *saveSub;
@@ -488,8 +486,19 @@ extCellFile(def, f, doLength)
     /* If "extract do unique" was specified, then make labels in the
      * cell unique.
      */
+
     if (ExtOptions & EXT_DOUNIQUE)
+    {
+	if (ExtOptions & EXT_DOUNIQNOTOPPORTS)
+	{
+	    if (isTop)
+		extUniqueCell(def, EXT_UNIQ_TEMP_NOPORTS);
+	    else
 		extUniqueCell(def, EXT_UNIQ_TEMP);
+	}
+	else
+	    extUniqueCell(def, EXT_UNIQ_TEMP);
+    }
 
     /* Prep any isolated substrate areas */
     if (ExtOptions & EXT_DOEXTRESIST)
@@ -519,7 +528,7 @@ extCellFile(def, f, doLength)
     ExtResetTiles(def, CLIENTDEFAULT);
 
     /* Final pass: extract length information if desired */
-    if (!SigInterruptPending && doLength && (ExtOptions & EXT_DOLENGTH))
+    if (!SigInterruptPending && isTop && (ExtOptions & EXT_DOLENGTH))
 	extLength(extParentUse, f);
 
     UndoEnable();

extract/ExtHier.c

@@ -281,6 +281,13 @@ extHierSubstrate(ha, use, x, y)
 	    nn->nn_next = node2->node_names->nn_next;
 	    node2->node_names->nn_next = node1->node_names;
 	    node2->node_len += node1->node_len;
+	    if (node2->node_ports)
+	    {
+		ExtConnList *nport;
+		for (nport = node2->node_ports; nport && nport->r_next;
+				nport = nport->r_next);
+		if (nport) nport->r_next = node1->node_ports;
+	    }
 	    freeMagic((char *)node1);
 	}
 	else
@@ -294,6 +301,13 @@ extHierSubstrate(ha, use, x, y)
 	    nn->nn_next = node1->node_names;
 	    node1->node_names = node2->node_names;
 	    node1->node_len += node2->node_len;
+	    if (node1->node_ports)
+	    {
+		ExtConnList *nport;
+		for (nport = node1->node_ports; nport && nport->r_next;
+				nport = nport->r_next);
+		if (nport) nport->r_next = node2->node_ports;
+	    }
 	    freeMagic((char *)node2);
 	}
     }
@@ -499,6 +513,13 @@ extHierConnectFunc1(oneTile, dinfo, ha)
 	    		nn->nn_next = node2->node_names->nn_next;
 	    		node2->node_names->nn_next = node1->node_names;
 			node2->node_len += node1->node_len;
+			if (node2->node_ports)
+			{
+			    ExtConnList *nport;
+			    for (nport = node2->node_ports; nport && nport->r_next;
+					nport = nport->r_next);
+			    if (nport) nport->r_next = node1->node_ports;
+			}
 		    	freeMagic((char *) node1);
 		    }
 		    else
@@ -514,6 +535,13 @@ extHierConnectFunc1(oneTile, dinfo, ha)
 		    	nn->nn_next = node1->node_names;
 		    	node1->node_names = node2->node_names;
 			node1->node_len += node2->node_len;
+			if (node1->node_ports)
+			{
+			    ExtConnList *nport;
+			    for (nport = node1->node_ports; nport && nport->r_next;
+					nport = nport->r_next);
+			    if (nport) nport->r_next = node2->node_ports;
+			}
 		    	freeMagic((char *) node2);
 		    }
 		}
@@ -523,6 +551,48 @@ extHierConnectFunc1(oneTile, dinfo, ha)
 }
 
 /*
+ *------------------------------------------------------------------------
+ *
+ * extHierFindTopNode --
+ *
+ * Simple callback function used in extHierConnectFunc2() to retrieve
+ * the node name of a node in the CellDef being extracted at a specific
+ * point.  If there is no node at that point (indicating that there is
+ * paint in a subcell at that location but no paint in the top level
+ * cell) then return NULL.
+ *
+ * Returns:
+ *	1 if a node is found, otherwise 0 to keep the search going.
+ *
+ * Side effects:
+ *	A pointer to the node is returned in the clientData field.
+ *
+ *------------------------------------------------------------------------
+ */
+
+int
+extHierFindTopNode(Tile *tile,
+	TileType dinfo,
+	ExtRegion **nreg)
+{
+    ExtRegion *tireg;
+
+    tireg = (ExtRegion *)ExtGetRegion(tile, dinfo);
+    if ((ClientData)tireg == CLIENTDEFAULT)
+    {
+	*nreg = (ExtRegion *)0;
+	return 0;
+    }
+    else
+    {
+	*nreg = tireg;
+	return 1;
+    }
+}
+
+/*
+ *------------------------------------------------------------------------
+ *
  * extHierConnectFunc2 --
  *
  * Called once for each tile 'cum' in extHierCumFlat->et_use->cu_def
@@ -538,6 +608,8 @@ extHierConnectFunc1(oneTile, dinfo, ha)
  *	if the types of ha->hierOneTile and 'cum' connect.
  *	Otherwise, if the tiles actually overlap (as opposed
  *	to merely abut), mark it with feedback as an error.
+ *
+ *------------------------------------------------------------------------
  */
 
 int
@@ -608,6 +680,53 @@ extHierConnectFunc2(cum, dinfo, ha)
 
 	if (node1 != node2)
 	{
+	    ExtConnList *newport;
+	    int pNum;
+
+	    if (ExtOptions & EXT_DOEXTRESIST)
+	    {
+		NodeRegion *topnode = NULL;
+
+		/* Record the area of connection for both nodes in their
+		 * respective coordinate systems, and the name of the
+		 * cell use to which the connection is made.
+		 */
+		newport = (ExtConnList *)mallocMagic(sizeof(ExtConnList));
+		newport->r_r = r;
+		newport->r_type = ttype;
+		newport->r_useid = ha->ha_subUse->cu_id;
+
+		/* Find a node at the given location in et_lookNames (the
+		 * original CellDef being extracted).  If there is no node
+		 * in the def itself then the entry is NULL.
+		 */
+		for (pNum = PL_TECHDEPBASE; pNum < DBNumPlanes; pNum++)
+		{
+		    if (TTMaskHasType(&DBPlaneTypes[pNum], ttype))
+		    {
+			/* Make sure that the rect is not zero area */
+			if (r.r_xtop == r.r_xbot)
+			{
+			    r.r_xtop++;
+			    r.r_xbot--;
+			}
+			if (r.r_ytop == r.r_ybot)
+			{
+			    r.r_ytop++;
+			    r.r_ybot--;
+			}
+
+			DBSrPaintArea((Tile *)NULL,
+				ha->ha_cumFlat.et_lookNames->cd_planes[pNum],
+				&r, &DBConnectTbl[ttype], extHierFindTopNode,
+				(ClientData)PTR2CD(&topnode));
+			newport->r_upnode = PTR2CD(topnode);
+
+			newport->r_downnode = PTR2CD(node2->node_names);
+		    }
+		}
+	    }
+
 	    if (node1->node_len < node2->node_len)
 	    {
 	    	/*
@@ -622,6 +741,12 @@ extHierConnectFunc2(cum, dinfo, ha)
 	    	node2->node_names->nn_next = node1->node_names;
 	        node2->node_len += node1->node_len;
 	        freeMagic((char *) node1);
+
+		if (ExtOptions & EXT_DOEXTRESIST)
+		{
+		    newport->r_next = node2->node_ports;
+		    node2->node_ports = newport;
+		}
 	    }
 	    else
 	    {
@@ -637,6 +762,12 @@ extHierConnectFunc2(cum, dinfo, ha)
 	        node1->node_names = node2->node_names;
 	        node1->node_len += node2->node_len;
 	        freeMagic((char *) node2);
+
+		if (ExtOptions & EXT_DOEXTRESIST)
+		{
+		    newport->r_next = node1->node_ports;
+		    node1->node_ports = newport;
+		}
 	    }
 	}
     }
@@ -733,6 +864,13 @@ extHierConnectFunc3(cum, dinfo, ha)
 	    	nn->nn_next = node2->node_names->nn_next;
 	    	node2->node_names->nn_next = node1->node_names;
 	    	node2->node_len += node1->node_len;
+		if (node2->node_ports)
+		{
+		    ExtConnList *nport;
+		    for (nport = node2->node_ports; nport && nport->r_next;
+				nport = nport->r_next);
+		    if (nport) nport->r_next = node1->node_ports;
+		}
 	    	freeMagic((char *) node1);
 	    }
 	    else
@@ -748,6 +886,13 @@ extHierConnectFunc3(cum, dinfo, ha)
 	    	nn->nn_next = node1->node_names;
 	    	node1->node_names = node2->node_names;
 	    	node1->node_len += node2->node_len;
+		if (node1->node_ports)
+		{
+		    ExtConnList *nport;
+		    for (nport = node1->node_ports; nport && nport->r_next;
+				nport = nport->r_next);
+		    if (nport) nport->r_next = node2->node_ports;
+		}
 	    	freeMagic((char *) node2);
 	    }
 	}
@@ -916,6 +1061,7 @@ extOutputConns(table, outf)
     NodeName *nfirst;
     HashSearch hs;
     HashEntry *he;
+    ExtConnList *nport, *npnext;
 
     HashStartSearch(&hs);
     while ((he = HashNext(table, &hs)))
@@ -948,7 +1094,6 @@ extOutputConns(table, outf)
 				node->node_pa[n].pa_area,
 				node->node_pa[n].pa_perim);
 		fprintf(outf, "\n");
-
 		nn->nn_node = (Node *) NULL;		/* Processed */
 
 		/* Subsequent merges */
@@ -960,6 +1105,23 @@ extOutputConns(table, outf)
 		}
 	    }
 	    nn->nn_node = (Node *) NULL;
+	    for (nport = node->node_ports; nport;)
+	    {
+		LabRegion *lreg = (LabRegion *)CD2PTR(nport->r_upnode);
+		NodeName *nn2 = (NodeName *)CD2PTR(nport->r_downnode);
+
+		npnext = nport->r_next;
+		/* Output port positions */
+		fprintf(outf, "connect %d %d %d %d %s \"%s\" \"%s\"\n",
+			nport->r_r.r_xbot, nport->r_r.r_ybot,
+			nport->r_r.r_xtop, nport->r_r.r_ytop,
+			DBTypeShortName(nport->r_type),
+			(lreg == (LabRegion *)NULL) ? "None" :
+				extNodeName(lreg),
+			(nn2) ? nn2->nn_name : "None");
+		freeMagic((char *)nport);
+		nport = npnext;
+	    }
 	    freeMagic((char *) node);
 	}
 	freeMagic((char *) nfirst);
@@ -1005,6 +1167,7 @@ extHierNewNode(he)
     node->node_names = nn;
     node->node_cap = (CapValue) 0;
     node->node_len = 1;
+    node->node_ports = (ExtConnList *)NULL;
     for (n = 0; n < nclasses; n++)
 	node->node_pa[n].pa_perim = node->node_pa[n].pa_area = 0;
     HashSetValue(he, (char *) nn);

extract/ExtInter.c

@@ -272,7 +272,7 @@ extInterSubtreeElement(use, trans, x, y, r)
 int
 extInterSubtreeTile(tile, dinfo, cxp)
     Tile *tile;
-    TileType dinfo;
+    TileType dinfo;	/* (unused) */
     TreeContext *cxp;
 {
     SearchContext newscx;
@@ -343,8 +343,9 @@ extInterOverlapSubtree(scx)
  */
 
 int
-extInterOverlapTile(tile, cxp)
+extInterOverlapTile(tile, dinfo, cxp)
     Tile *tile;
+    TileType dinfo;		/* (unused) */
     TreeContext *cxp;
 {
     SearchContext *scx = cxp->tc_scx;

extract/ExtMain.c

@@ -473,6 +473,19 @@ ExtUnique(rootUse, option)
     /* Fix up bounding boxes if they've changed */
     DBFixMismatch();
 
+    /* Because the "extract unique" does the same thing as "extract do unique"
+     * but the options may be different, disable "extract do unique" when
+     * "extract unique" is run, on the assumption that no user would
+     * intentionally use both methods.  If "do unique" was set and got
+     * disabled, then flag a warning.
+     */
+    if (ExtOptions & EXT_DOUNIQUE)
+    {
+	ExtOptions &= ~EXT_DOUNIQUE;
+	TxPrintf("Warning:  Extract option \"do unique\" disabled because "
+		"\"extract unique\" was run.\n");
+    }
+
     /* Mark all defs as being unvisited */
     (void) DBCellSrDefs(0, extDefInitFunc, (ClientData) 0);
 

extract/ExtSubtree.c

@@ -54,12 +54,14 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 /* C99 compat */
 #include "drc/drc.h"
 
-#ifdef	exactinteractions
 /*
- * If "exactinteractions" is defined, we use an experimental algorithm
+ * If "exactinteractions" is defined, use an experimental algorithm
- * for finding exact interaction areas.  Currently it doesn't work too
+ * for finding exact interaction areas.  Currently it doesn't work
- * well, so we leave it turned off.
+ * too well, so it is disabled.
  */
+/* #define exactinteractions */
+
+#ifdef	exactinteractions
 int ExtInterBloat = 10;
 #endif	/* exactinteractions */
 

extract/ExtUnique.c

@@ -66,6 +66,8 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
  *	    label.  This way, the unique label form can be used by the
  *	    extraction code but labels (and port indexes) can be reverted
  *	    afterward, and no permanent change is made to the circuit.
+ *	Option EXT_UNIQ_TEMP_NOPORTS is a combination of EXT_UNIQ_TEMP and
+ *	    EXT_UNIQ_NOPORTS.
  *
  * Results:
  *	Returns the number of warnings generated.
@@ -226,8 +228,9 @@ extMakeUnique(def, ll, lreg, lregList, labelHash, option)
     text = ll->ll_label->lab_text;
     if (option == EXT_UNIQ_ALL || option == EXT_UNIQ_TEMP)
 	goto makeUnique;
-    else if ((option == EXT_UNIQ_NOPORTS || option == EXT_UNIQ_NOTOPPORTS)
+    else if ((option == EXT_UNIQ_NOPORTS || option == EXT_UNIQ_NOTOPPORTS ||
-		&& !(ll->ll_label->lab_flags & PORT_DIR_MASK))
+		option == EXT_UNIQ_TEMP_NOPORTS) &&
+		!(ll->ll_label->lab_flags & PORT_DIR_MASK))
 	goto makeUnique;
 
     cpend = strchr(text, '\0');
@@ -326,7 +329,8 @@ makeUnique:
 	    saveLab = *lab;
 
 	    /* Flag this label as having been modified */
-	    if (option == EXT_UNIQ_TEMP) flags |= LABEL_UNIQUE;
+	    if ((option == EXT_UNIQ_TEMP) || (option == EXT_UNIQ_TEMP_NOPORTS))
+		flags |= LABEL_UNIQUE;
 
 	    DBRemoveLabel(def, lab);
 	    DBPutFontLabel(def, &saveLab.lab_rect,

extract/extract.h

@@ -71,11 +71,12 @@ extern const char * const extDevTable[];
 #define	EXT_DORESISTANCE	0x008	/* Extract lumped resistance */
 #define	EXT_DOLENGTH		0x010	/* Extract pathlengths */
 #define	EXT_DOFRINGEHALO	0x020	/* Distributed fringe capacitance */
-#define	EXT_DOALL		0x03f	/* ALL OF THE ABOVE */
+#define EXT_DOUNIQUE		0x100	/* Force unique nodes during extraction */
+#define	EXT_DOALL		0x13f	/* ALL OF THE ABOVE */
 #define	EXT_DOLABELCHECK	0x040	/* Check for connections by label */
 #define EXT_DOALIASES		0x080	/* Output all node aliases */
-#define EXT_DOUNIQUE		0x100	/* Force unique nodes during extraction */
 #define EXT_DOEXTRESIST		0x200	/* Do full R-C extraction */
+#define EXT_DOUNIQNOTOPPORTS	0x400	/* Ignore top cell ports w/EXT_DOUNIQUE */
 
 extern int ExtOptions;		/* Bitmask of above */
 extern char *ExtLocalPath;	/* If non-NULL, location to write .ext files */ 
@@ -86,6 +87,7 @@ extern char *ExtLocalPath;	/* If non-NULL, location to write .ext files */
 #define EXT_UNIQ_NOPORTS	2
 #define EXT_UNIQ_NOTOPPORTS	3
 #define EXT_UNIQ_TEMP		4	/* Used only with "EXT_DOUNIQUE" */
+#define EXT_UNIQ_TEMP_NOPORTS	5	/* Used only with "EXT_DOUNIQUE" */
 
 extern bool ExtTechLine();
 extern void ExtTechInit();

extract/extractInt.h

@@ -981,6 +981,7 @@ typedef struct node
 				 * in the list is the "official" node name.
 				 */
     int		 node_len;	/* Number of entries in node_names */
+    ExtConnList	*node_ports;	/* List of areas that connect to other cells */
     CapValue	 node_cap;	/* Capacitance to substrate */
     PerimArea	 node_pa[1];	/* Dummy; each node actually has
 				 * ExtCurStyle->exts_numResistClasses

magic/magicps.pro

@@ -26,17 +26,19 @@ StipplePattern begin
  /FontMatrix [1 0 0 1 0 0] def
  /FontBBox [0 0 1 1] def
  /Encoding 256 array def
- /PattName (P0) def
+ /PattName (P000) def
- /tmpStr 1 string def
+ /tmpStr 3 string def
  /NoPatt {<00>} def
  0 1 255 { Encoding exch /NoPatt put } for
  /BuildChar {
    1 0 0 0 1 1 setcachedevice exch begin Encoding exch get load
    64 64 true [64 0 0 64 0 0] 5 -1 roll imagemask end } def
 end  
-/dp { StipplePattern begin dup 30 tmpStr cvrs PattName exch 1 exch
+/dp { StipplePattern begin 
-   putinterval PattName cvn dup Encoding exch 4 -1 roll exch put exch
+   dup 10 tmpStr cvrs /num exch def 
-   store end } def
+   PattName 1 num putinterval 
+   PattName 0 num length 1 add getinterval cvn 
+   dup Encoding exch 4 -1 roll exch put exch store end } def
 /sf { findfont exch scalefont setfont } bind def
 /sp { patterns setfont 2 setlinewidth } def
 /lb { gsave translate 0 0 moveto /just exch def gsave dup true charpath
@@ -68,4 +70,3 @@ end
    x y moveto w y lineto w h lineto x h lineto closepath clip bx } def
 /tb {1 sub 3 1 roll gsave newpath moveto {lineto} repeat closepath clip pathbbox
    /h exch def /w exch def /y exch def /x exch def bx } def
-

plot/plotVers.c

@@ -1218,7 +1218,7 @@ PlotVersatec(scx, layers, xMask, user_scale)
 
     /* Compute the name of the file to use for output, and open it. */
 
-    sprintf(fileName, "%s/magicPlotXXXXXX", PlotTempDirectory);
+    snprintf(fileName, 200, "%s/magicPlotXXXXXX", PlotTempDirectory);
     result = mkstemp(fileName);
     if (result == -1)
     {
@@ -1474,7 +1474,7 @@ PlotVersatec(scx, layers, xMask, user_scale)
 
     TxPrintf("\n");
     fclose(file);
-    sprintf(command, PlotVersCommand, PlotVersPrinter, fileName);
+    snprintf(command, 300, PlotVersCommand, PlotVersPrinter, fileName);
     if (system(command) != 0)
     {
 	TxError("Couldn't execute spooler command to print \"%s\"\n",

resis/ResBasic.c

@@ -27,64 +27,24 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 /*
  *--------------------------------------------------------------------------
  *
- * resNodeIsPort --
+ * resMakePortBreakpoints --
- *
- *	If the given position is inside any port declared on the tile,
- *	change the node name to the port name.  Remove the port
- *	declaration if it was used.
- *
- *--------------------------------------------------------------------------
- */
-
-void
-resNodeIsPort(node, x, y, tile)
-    resNode *node;
-    int	    x;
-    int	    y;
-    Tile    *tile;
-{
-    Rect 	*rect;
-    Point 	p;
-    resPort 	*pl, *lp;
-    resInfo	*info = (resInfo *)TiGetClientPTR(tile);
-
-    p.p_x = x;
-    p.p_y = y;
-
-    for (pl = info->portList; pl; pl = pl->rp_nextPort)
-    {
-	rect = &(pl->rp_bbox);
-	if (GEO_ENCLOSE(&p, rect))
-	{
-	    node->rn_name = pl->rp_nodename;
-	    if (info->portList == pl)
-		info->portList = pl->rp_nextPort;
-	    else
-	    {
-	        for (lp = info->portList; lp && (lp->rp_nextPort != pl);
-			lp = lp->rp_nextPort);
-		lp->rp_nextPort = pl->rp_nextPort;
-	    }
-	    freeMagic(pl);
-	    break;
-	}
-    }
-}
-
-/*
- *--------------------------------------------------------------------------
- *
- * resAllPortNodes --
  *
  *	Generate new nodes and breakpoints for every unused port declared
  *	on a tile.  However, if "startpoint" is inside the port position,
  *	then it has already been processed, so ignore it.
  *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Adds breakpoints where ports (drivers, sinks, or labels) have been
+ *	defined as connected to the tile.
+ *
  *--------------------------------------------------------------------------
  */
 
 void
-resAllPortNodes(tile, list)
+resMakePortBreakpoints(tile, list)
     Tile 	*tile;
     resNode	**list;
 {
@@ -92,6 +52,7 @@ resAllPortNodes(tile, list)
     resNode	*resptr;
     resPort 	*pl;
     resInfo	*info = (resInfo *)TiGetClientPTR(tile);
+    ResConnect	*connect;
 
     free_magic1_t mm1 = freeMagic1_init();
     for (pl = info->portList; pl; pl = pl->rp_nextPort)
@@ -103,13 +64,30 @@ resAllPortNodes(tile, list)
 	resptr->rn_status = TRUE;
 	resptr->rn_noderes = 0;
 	resptr->rn_name = pl->rp_nodename;
+
+	/* Link back to the resnode from the ResConnect record */
+	connect = pl->rp_connect;
+	connect->rc_node = resptr;
+
 	ResAddToQueue(resptr, list);
-	NEWBREAK(resptr, tile, x, y, NULL);
+	ResNewBreak(resptr, tile, x, y, NULL);
 	freeMagic1(&mm1, pl);
     }
     freeMagic1_end(&mm1);
 }
 
+/*
+ * Structure used by ResEachTile for the callback to ResMultiPlaneFunc()
+ * to pass a pointer to the tile being processed, and the terminal being
+ * searched.
+ */
+
+typedef struct tile_and_term
+{
+    Tile *tat_tile;
+    int   tat_term;
+} TileAndTerm;
+
 /*
  *--------------------------------------------------------------------------
  *
@@ -128,12 +106,13 @@ resAllPortNodes(tile, list)
  */
 
 int
-ResMultiPlaneFunc(tile, dinfo, tpptr)
+ResMultiPlaneFunc(tile, dinfo, tat)
     Tile *tile;
     TileType dinfo;	/* Not used, but needs to be handled */
-    Tile **tpptr;
+    TileAndTerm *tat;
 {
-    Tile *tp = *tpptr;
+    Tile *tp = tat->tat_tile;
+    int  term = tat->tat_term;
     int	 xj, yj;
 
     /* Simplified split tile handling---Ignore the right side of
@@ -146,7 +125,7 @@ ResMultiPlaneFunc(tile, dinfo, tpptr)
 
     xj = (LEFT(tile) + RIGHT(tile)) / 2;
     yj = (TOP(tile) + BOTTOM(tile)) / 2;
-    ResNewSDDevice(tp, tile, xj, yj, OTHERPLANE, &ResNodeQueue);
+    ResNewTermDevice(tp, tile, term, xj, yj, OTHERPLANE, &ResNodeQueue);
 
     return 0;
 }
@@ -195,7 +174,44 @@ ResSubstrateFunc(tile, dinfo, tpptr)
 /*
  *--------------------------------------------------------------------------
  *
- * ResEachTile--for each tile, make a list of all possible current sources/
+ * ResStartTile --
+ *
+ *   For the tile at the starting point of the net, create an initial
+ *   resNode entry.
+ *
+ *  Results:
+ *	None.
+ *
+ *  Side Effects:
+ *	creates a node.
+ *
+ *
+ *--------------------------------------------------------------------------
+ */
+
+void
+ResStartTile(tile, x, y)
+    Tile 	*tile;
+    int		x, y;
+
+{
+    resNode	*resptr;
+
+    resptr = (resNode *) mallocMagic((unsigned)(sizeof(resNode)));
+    InitializeResNode(resptr, x, y, RES_NODE_ORIGIN);
+    resptr->rn_status = TRUE;
+    resptr->rn_noderes = 0;
+    ResAddToQueue(resptr, &ResNodeQueue);
+    ResNewBreak(resptr, tile, x, y, NULL);
+    if (resCurrentNode == NULL) resCurrentNode = resptr;
+}
+
+/*
+ *--------------------------------------------------------------------------
+ *
+ * ResEachTile --
+ *
+ *   For each tile, make a list of all possible current sources/
  *   sinks including contacts, devices, and junctions.  Once this
  *   list is made, calculate the resistor network for the tile.
  *
@@ -214,10 +230,8 @@ ResSubstrateFunc(tile, dinfo, tpptr)
 #define IGNORE_BOTTOM	8
 
 bool
-ResEachTile(tile, startpoint)
+ResEachTile(tile)
     Tile 	*tile;
-    Point 	*startpoint;
-
 {
     Tile 	*tp;
     resNode	*resptr;
@@ -226,14 +240,12 @@ ResEachTile(tile, startpoint)
     int		xj, yj, i;
     bool	merged;
     tElement	*tcell;
-    resInfo	*tstructs= (resInfo *)TiGetClientPTR(tile);
+    resInfo	*tstructs = (resInfo *)TiGetClientPTR(tile);
     ExtDevice   *devptr;
     int		sides;
 
     ResTileCount++;
 
-    /* Process startpoint, if any. */
-
     /* Simplification:  Split tiles handle either the non-space side,
      * or if neither side is space, then handle the left side.
      */
@@ -258,21 +270,7 @@ ResEachTile(tile, startpoint)
 	t1 = TiGetTypeExact(tile);
     }
 
-    if (startpoint != (Point *) NULL)
+    if (TTMaskHasType(&(ExtCurStyle->exts_deviceMask), t1))
-    {
-	int x = startpoint->p_x;
-	int y = startpoint->p_y;
-	resptr = (resNode *) mallocMagic((unsigned)(sizeof(resNode)));
-	InitializeResNode(resptr, x, y, RES_NODE_ORIGIN);
-	resptr->rn_status = TRUE;
-	resptr->rn_noderes = 0;
-	ResAddToQueue(resptr, &ResNodeQueue);
-	NEWBREAK(resptr, tile, x, y, NULL);
-	if (resCurrentNode == NULL) resCurrentNode = resptr;
-	resNodeIsPort(resptr, x, y, tile);
-    }
-
-    if TTMaskHasType(&(ExtCurStyle->exts_deviceMask), t1)
     {
 	/*
 	 * The device is put in the center of the tile. This is fine
@@ -295,9 +293,7 @@ ResEachTile(tile, startpoint)
 		InitializeResNode(resptr, x, y, RES_NODE_JUNCTION);
 		resptr->rn_te = tcell;
 		ResAddToQueue(resptr, &ResNodeQueue);
-		resNodeIsPort(resptr, x, y, tile);
+		ResNewBreak(resptr, tile, resptr->rn_loc.p_x,
-
-		NEWBREAK(resptr, tile, resptr->rn_loc.p_x,
 		     			resptr->rn_loc.p_y, NULL);
 	    }
 	}
@@ -326,7 +322,7 @@ ResEachTile(tile, startpoint)
 
     /* left */
     if (!(sides & IGNORE_LEFT))
-    for (tp = BL(tile); BOTTOM(tp) < TOP(tile); tp=RT(tp))
+    for (tp = BL(tile); BOTTOM(tp) < TOP(tile); tp = RT(tp))
     {
 	t2 = TiGetRightType(tp);
 	if (TTMaskHasType(&(ExtCurStyle->exts_deviceMask), t2))
@@ -341,14 +337,14 @@ ResEachTile(tile, startpoint)
 			/* found device */
 			xj = LEFT(tile);
 			yj = (TOP(tp) + BOTTOM(tp)) >> 1;
-			ResNewSDDevice(tile, tp, xj, yj, RIGHTEDGE, &ResNodeQueue);
+			ResNewTermDevice(tile, tp, i, xj, yj, RIGHTEDGE, &ResNodeQueue);
 			break;
 		    }
 		}
 		if (i < devptr->exts_deviceSDCount) break;
 	    }
 	}
-	if TTMaskHasType(&(ExtCurStyle->exts_nodeConn[t1]), t2)
+	if (TTMaskHasType(&(ExtCurStyle->exts_nodeConn[t1]), t2))
 	{
 	    /* tile is junction */
 	    xj = LEFT(tile);
@@ -359,7 +355,7 @@ ResEachTile(tile, startpoint)
 
     /* right */
     if (!(sides & IGNORE_RIGHT))
-    for (tp = TR(tile); TOP(tp) > BOTTOM(tile); tp=LB(tp))
+    for (tp = TR(tile); TOP(tp) > BOTTOM(tile); tp = LB(tp))
     {
 	t2 = TiGetLeftType(tp);
 	if (TTMaskHasType(&(ExtCurStyle->exts_deviceMask), t2))
@@ -374,18 +370,18 @@ ResEachTile(tile, startpoint)
 			/* found device */
 			xj = RIGHT(tile);
 			yj = (TOP(tp) + BOTTOM(tp)) >> 1;
-			ResNewSDDevice(tile, tp, xj, yj, LEFTEDGE, &ResNodeQueue);
+			ResNewTermDevice(tile, tp, i, xj, yj, LEFTEDGE, &ResNodeQueue);
 			break;
 		    }
 		}
 		if (i < devptr->exts_deviceSDCount) break;
 	    }
 	}
-	if TTMaskHasType(&ExtCurStyle->exts_nodeConn[t1], t2)
+	if (TTMaskHasType(&ExtCurStyle->exts_nodeConn[t1], t2))
 	{
 	    /* tile is junction */
 	    xj = RIGHT(tile);
-	    yj = (MAX(BOTTOM(tile),BOTTOM(tp)) + MIN(TOP(tile), TOP(tp))) >> 1;
+	    yj = (MAX(BOTTOM(tile), BOTTOM(tp)) + MIN(TOP(tile), TOP(tp))) >> 1;
 	    (void)ResProcessJunction(tile, tp, xj, yj, &ResNodeQueue);
 	}
     }
@@ -407,25 +403,25 @@ ResEachTile(tile, startpoint)
 			/* found device */
 			yj = TOP(tile);
 			xj = (LEFT(tp) + RIGHT(tp)) >> 1;
-			ResNewSDDevice(tile, tp, xj, yj, BOTTOMEDGE, &ResNodeQueue);
+			ResNewTermDevice(tile, tp, i, xj, yj, BOTTOMEDGE, &ResNodeQueue);
 			break;
 		    }
 		}
 		if (i < devptr->exts_deviceSDCount) break;
 	    }
 	}
-	if TTMaskHasType(&ExtCurStyle->exts_nodeConn[t1], t2)
+	if (TTMaskHasType(&ExtCurStyle->exts_nodeConn[t1], t2))
 	{
 	    /* tile is junction */
 	    yj = TOP(tile);
-	    xj = (MAX(LEFT(tile),LEFT(tp)) + MIN(RIGHT(tile),RIGHT(tp))) >> 1;
+	    xj = (MAX(LEFT(tile), LEFT(tp)) + MIN(RIGHT(tile), RIGHT(tp))) >> 1;
 	    ResProcessJunction(tile, tp, xj, yj, &ResNodeQueue);
 	}
     }
 
     /* bottom */
     if (!(sides & IGNORE_BOTTOM))
-    for (tp = LB(tile); LEFT(tp) < RIGHT(tile); tp=TR(tp))
+    for (tp = LB(tile); LEFT(tp) < RIGHT(tile); tp = TR(tp))
     {
 	t2 = TiGetTopType(tp);
 	if (TTMaskHasType(&(ExtCurStyle->exts_deviceMask), t2))
@@ -440,29 +436,30 @@ ResEachTile(tile, startpoint)
 			/* found device */
 			yj = BOTTOM(tile);
 			xj = (LEFT(tp) + RIGHT(tp)) >> 1;
-			ResNewSDDevice(tile, tp, xj, yj, TOPEDGE, &ResNodeQueue);
+			ResNewTermDevice(tile, tp, i, xj, yj, TOPEDGE, &ResNodeQueue);
 			break;
 		    }
 		}
 		if (i < devptr->exts_deviceSDCount) break;
 	    }
 	}
-	if TTMaskHasType(&(ExtCurStyle->exts_nodeConn[t1]), t2)
+	if (TTMaskHasType(&(ExtCurStyle->exts_nodeConn[t1]), t2))
 	{
 	    /* tile is junction */
 	    yj = BOTTOM(tile);
-	    xj = (MAX(LEFT(tile),LEFT(tp)) + MIN(RIGHT(tile),RIGHT(tp))) >> 1;
+	    xj = (MAX(LEFT(tile), LEFT(tp)) + MIN(RIGHT(tile), RIGHT(tp))) >> 1;
 	    ResProcessJunction(tile, tp, xj, yj, &ResNodeQueue);
 	}
     }
 
-    /* Check for source/drain on other planes (e.g., capacitors, bipolars, ...) */
+    /* Check for terminals on other planes (e.g., capacitors, bipolars, ...) */
 
-    if (TTMaskHasType(&ResSDTypesBitMask, t1))
+    if (TTMaskHasType(&ResTermTypesBitMask, t1))
     {
 	Rect r;
 	int pNum;
 	TileTypeBitMask devMask;
+	TileAndTerm tat;
 
 	TiToRect(tile, &r);
 
@@ -470,20 +467,29 @@ ResEachTile(tile, startpoint)
 	{
 	    if (DBTypeOnPlane(t1, pNum)) continue;
 
-	    /* NOTE:  This is ridiculously inefficient and should be done
-	     * in a different way.
-	     */
-
-	    TTMaskZero(&devMask);
-	    for (t2 = TT_TECHDEPBASE; t2 < DBNumUserLayers; t2++)
 	    for (devptr = ExtCurStyle->exts_device[t2]; devptr;
 			    devptr = devptr->exts_next)
+	    {
 		for (i = 0; !TTMaskIsZero(&devptr->exts_deviceSDTypes[i]); i++)
-			if (TTMaskHasType(&devptr->exts_deviceSDTypes[i], t1))
+		{
-			    TTMaskSetType(&devMask, t2);
+		    /* Check if any type in the terminal type list exists on this
+		     * plane before calling the search function.
+		     */
+		    TileTypeBitMask termtypes;
 
+		    TTMaskAndMask3(&termtypes, &devptr->exts_deviceSDTypes[i],
+				&DBPlaneTypes[pNum]);
+
+		    if (TTMaskIsZero(&termtypes))
+		    {
+			tat.tat_tile = tile;
+			tat.tat_term = i;
 			DBSrPaintArea((Tile *)NULL, ResUse->cu_def->cd_planes[pNum],
-			&r, &devMask, ResMultiPlaneFunc, (ClientData)&tile);
+				&r, &devptr->exts_deviceSDTypes[i],
+				ResMultiPlaneFunc, (ClientData)&tat);
+		    }
+		}
+	    }
 	}
     }
 
@@ -519,7 +525,7 @@ ResEachTile(tile, startpoint)
 
     tstructs->ri_status |= RES_TILE_DONE;
 
-    resAllPortNodes(tile, &ResNodeQueue);
+    resMakePortBreakpoints(tile, &ResNodeQueue);
 
     merged = ResCalcTileResistance(tile, tstructs, &ResNodeQueue,
 			&ResNodeList);

resis/ResChecks.c

@@ -61,7 +61,7 @@ ResSanityChecks(nodename, resistorList, nodeList, devlist)
     {
      	resSanityStack = StackNew(64);
     }
-    for (node = nodeList; node != NULL; node=node->rn_more)
+    for (node = nodeList; node != NULL; node = node->rn_more)
     {
      	node->rn_status &= ~RES_REACHED_NODE;
 	if (node->rn_why & RES_NODE_ORIGIN)
@@ -133,7 +133,7 @@ ResSanityChecks(nodename, resistorList, nodeList, devlist)
 	}
     }
     foundorigin = 0;
-    for (node = nodeList; node != NULL; node=node->rn_more)
+    for (node = nodeList; node != NULL; node = node->rn_more)
     {
      	if ((node->rn_status & RES_REACHED_NODE) == 0)
 	{

resis/ResDebug.c

@@ -128,11 +128,11 @@ ResPrintDeviceList(fp, list)
 	{
 	    if (list->rd_terminals[i] == NULL) continue;
 	    if (fp == stdout)
-		TxPrintf("%c (%d,%d) ",termtype[i],
+		TxPrintf("%c (%d,%d) ", termtype[i],
 	       		list->rd_terminals[i]->rn_loc.p_x,
 			list->rd_terminals[i]->rn_loc.p_y);
 	    else
-		fprintf(fp, "%c (%d,%d) ",termtype[i],
+		fprintf(fp, "%c (%d,%d) ", termtype[i],
 	       		list->rd_terminals[i]->rn_loc.p_x,
 			list->rd_terminals[i]->rn_loc.p_y);
 

resis/ResFract.c

@@ -106,7 +106,7 @@ enumerate:
 		}
 		else
 		{
-		    resTopTile=BL(resTopTile);
+		    resTopTile = BL(resTopTile);
 		}
 	    }
 	}
@@ -205,7 +205,7 @@ ResCheckConcavity(bot, top, tt)
 	    ylen = ypos - resWalkdown(bot, tt, xpos, ypos, NULL);
 	    if (xlen > ylen)
 	    {
-		(void) resWalkdown(bot,tt,xpos,ypos,ResSplitX);
+		(void) resWalkdown(bot, tt, xpos, ypos, ResSplitX);
 	    }
 	}
     }
@@ -274,7 +274,7 @@ int
 resWalkup(tile, tt, xpos, ypos, func)
     Tile	*tile;
     TileType	tt;
-    int		xpos,ypos;
+    int		xpos, ypos;
     Tile *	(*func)();
 
 {
@@ -443,7 +443,7 @@ ResSplitX(tile, x)
     Tile	*tp = TiSplitX(tile, x);
     Tile	*tp2;
 
-    TiSetBody(tp,tt);
+    TiSetBody(tp, tt);
     /* check to see if we can combine with the tiles above or below us */
     tp2 = RT(tile);
     if (TiGetType(tp2) == tt && LEFT(tp2) == LEFT(tile) && RIGHT(tp2) == RIGHT(tile))

resis/ResJunct.c

@@ -29,26 +29,31 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 /*
  *-------------------------------------------------------------------------
  *
- * ResNewSDDevice -- called when a device is reached via a piece of
+ * ResNewTermDevice --
- *			 diffusion. (Devices  reached via poly, i.e.
- *			 gates, are handled by ResEachTile.)
  *
- * Results:none
+ *	Called when a device is reached via a type in the device's
+ *	terminal type list (e.g., diffusion, for MOSFETs).  Note that
+ *	devices reached by the device type (e.g., poly, for MOSFETs)
+ *	are handled by ResEachTile.
  *
- * Side Effects: determines to which terminal (source or drain) node
+ * Results:
- * is connected. Makes new node if node hasn't already been created .
+ *	None
- * Allocates breakpoint in current tile for device.
+ *
+ * Side Effects:
+ *	Determines to which terminal (source or drain) node is connected.
+ *	Makes new node if node hasn't already been created.  Allocates
+ *	breakpoint in current tile for device.
  *
  *-------------------------------------------------------------------------
  */
 
 void
-ResNewSDDevice(tile, tp, xj, yj, direction, PendingList)
+ResNewTermDevice(tile, tp, n, xj, yj, direction, PendingList)
     Tile 	*tile, *tp;
-    int 	xj, yj, direction;
+    int 	n, xj, yj, direction;
     resNode	**PendingList;
 {
-    resNode	*resptr;
+    resNode	*resptr = NULL;
     resDevice	*resDev;
     tElement	*tcell;
     int		newnode;
@@ -64,7 +69,9 @@ ResNewSDDevice(tile, tp, xj, yj, direction, PendingList)
 
     ri = (resInfo *) TiGetClientPTR(tp);
     resDev = ri->deviceList;
-    if ((ri->sourceEdge & direction) != 0)
+    if (resDev == NULL) return;			/* Shouldn't happen? */
+    if ((((ri->sourceEdge & direction) != 0) && (resDev->rd_nterms == 4))
+		|| (resDev->rd_nterms > 2))
     {
 	if (resDev->rd_fet_source == (resNode *) NULL)
 	{
@@ -73,11 +80,9 @@ ResNewSDDevice(tile, tp, xj, yj, direction, PendingList)
 	    resDev->rd_fet_source = resptr;
 	}
 	else
-	{
 	    resptr = resDev->rd_fet_source;
     }
-    }
+    else if (resDev->rd_nterms > 3)
-    else
     {
 	if (resDev->rd_fet_drain == (resNode *) NULL)
 	{
@@ -86,10 +91,8 @@ ResNewSDDevice(tile, tp, xj, yj, direction, PendingList)
 	    resDev->rd_fet_drain = resptr;
 	}
 	else
-	{
 	    resptr = resDev->rd_fet_drain;
     }
-    }
     if (newnode)
     {
 	tcell = (tElement *) mallocMagic((unsigned)(sizeof(tElement)));
@@ -99,7 +102,8 @@ ResNewSDDevice(tile, tp, xj, yj, direction, PendingList)
 	resptr->rn_te = tcell;
 	ResAddToQueue(resptr, PendingList);
     }
-    NEWBREAK(resptr, tile, xj, yj, NULL);
+    if (resptr != NULL)
+	ResNewBreak(resptr, tile, xj, yj, NULL);
 }
 
 /*
@@ -131,20 +135,14 @@ ResNewSubDevice(tile, tp, xj, yj, direction, PendingList)
     ri = (resInfo *) TiGetClientPTR(tp);
     resDev = ri->deviceList;
 
-    /* Arrived at a device that has a terminal connected to substrate	*/
+    if (resDev->rd_fet_subs == (resNode *)NULL)
-    /* that is not a FET bulk terminal (e.g., varactor, diode).		*/
-    if (resDev->rd_nterms < 4) return;
-
-    if (resDev->rd_fet_subs == (resNode *) NULL)
     {
 	resptr = (resNode *) mallocMagic((unsigned)(sizeof(resNode)));
 	newnode = TRUE;
 	resDev->rd_fet_subs = resptr;
     }
     else
-    {
 	resptr = resDev->rd_fet_subs;
-    }
 
     if (newnode)
     {
@@ -155,7 +153,7 @@ ResNewSubDevice(tile, tp, xj, yj, direction, PendingList)
 	resptr->rn_te = tcell;
 	ResAddToQueue(resptr, PendingList);
     }
-    NEWBREAK(resptr, tile, xj, yj, NULL);
+    ResNewBreak(resptr, tile, xj, yj, NULL);
 }
 
 /*
@@ -213,10 +211,10 @@ ResProcessJunction(tile, tp, xj, yj, NodeList)
     junction->rj_nextjunction[1] = ri2->junctionList;
     ri2->junctionList = junction;
 
-    NEWBREAK(junction->rj_jnode,tile, junction->rj_loc.p_x, 
+    ResNewBreak(junction->rj_jnode, tile, junction->rj_loc.p_x, 
 		    junction->rj_loc.p_y, NULL);
 
-    NEWBREAK(junction->rj_jnode,tp, junction->rj_loc.p_x,
+    ResNewBreak(junction->rj_jnode, tp, junction->rj_loc.p_x,
 		    junction->rj_loc.p_y, NULL);
 
 }

resis/ResMain.c

@@ -40,8 +40,7 @@ resNode			*resCurrentNode;
 int			ResTileCount = 0;	/* Number of tiles rn_status */
 extern ExtRegion 	*ResFirst();
 extern Tile		*FindStartTile();
-extern int		ResEachTile();
+TileTypeBitMask		ResTermTypesBitMask;
-TileTypeBitMask		ResSDTypesBitMask;
 TileTypeBitMask		ResSubTypesBitMask;
 
 extern HashTable	ResNodeTable;
@@ -100,7 +99,7 @@ ResInitializeConn()
  *
  *  ResGetReCell --
  *
- * 	This procedure makes sure that ResUse,ResDef
+ * 	This procedure makes sure that ResUse, ResDef
  *	have been properly initialized to refer to a cell definition
  *	named "__RESIS__".
  *
@@ -148,51 +147,86 @@ void
 ResDissolveContacts(contacts)
     ResContactPoint *contacts;
 {
-    TileType t, oldtype;
+    TileType t, conttype;
     Tile *tp;
-    TileTypeBitMask residues;
+    TileType residue[NP][NT];
+    int pNum;
+
+    bzero((char *)residue, NP * NT * sizeof(TileType));
 
     for (; contacts != (ResContactPoint *)NULL; contacts = contacts->cp_nextcontact)
     {
-        oldtype=contacts->cp_type;
+        conttype = contacts->cp_type;
 
 #ifdef PARANOID
-	if (oldtype == TT_SPACE)
+	if (conttype == TT_SPACE)
-	    TxError("Error in Contact Dissolving for %s \n",ResCurrentNode);
+	    TxError("Error in Contact Dissolving for %s \n", ResCurrentNode);
 #endif
-	DBFullResidueMask(oldtype, &residues);
 
-	DBErase(ResUse->cu_def, &(contacts->cp_rect), oldtype);
+	/* Fill in details of the residue types for each contact type.
-	for (t = TT_TECHDEPBASE; t < DBNumTypes; t++)
+	 * This is done only once per contact type.  This could be refined
-	    if (TTMaskHasType(&residues, t))
+	 * further by temporarily changing the paint table directly or
-		DBPaint(ResUse->cu_def, &(contacts->cp_rect), t);
+	 * creating a separate paint table which erases contact cuts and
+	 * replaces them with the residues.
+	 */
 
-	tp = PlaneGetHint(ResDef->cd_planes[DBPlane(contacts->cp_type)]);
+	if (residue[DBPlane(conttype)][conttype] == TT_SPACE)
-	GOTOPOINT(tp, &(contacts->cp_rect.r_ll));
+	    for (pNum = PL_TECHDEPBASE; pNum < DBNumPlanes; pNum++)
+		residue[pNum][conttype] = DBPlaneToResidue(conttype, pNum);
+
+	for (pNum = PL_TECHDEPBASE; pNum < DBNumPlanes; pNum++)
+	{
+	    if (DBTypeOnPlane(conttype, pNum))
+	    {
+		DBPaintPlane(ResUse->cu_def->cd_planes[pNum], &(contacts->cp_rect), 
+			DBStdEraseTbl(conttype, pNum), (PaintUndoInfo *)NULL);
+		DBPaintPlane(ResUse->cu_def->cd_planes[pNum], &(contacts->cp_rect), 
+			DBStdPaintTbl(residue[pNum][conttype], pNum),
+			(PaintUndoInfo *)NULL);
+	    }
+	}
 
 #ifdef PARANOID
-	if (TiGetTypeExact(tp) == contacts->cp_type)
+	tp = PlaneGetHint(ResDef->cd_planes[DBPlane(conttype)]);
+	GOTOPOINT(tp, &(contacts->cp_rect.r_ll));
+	if (TiGetTypeExact(tp) == conttype)
 	    TxError("Error in Contact Preprocess Routines\n");
 #endif
     }
 }
 
+/* Structure used by ResMakeDriverSinkPorts() to pass information to
+ * ResAddPortFunc().  Contains a reference to a node, so that the
+ * link between the tile and the node can be maintained, and the
+ * driver or sink, which has the information about the position and
+ * tile type of the connection.
+ */
+
+typedef struct driversinkdata {
+    ResExtNode	*dsd_node;
+    ResConnect  *dsd_connect;
+} DriverSinkData;
+
 /*
  *---------------------------------------------------------------------------
  *
- *  ResMakePortBreakpoints --
+ *  ResMakeDriverSinkPorts --
  *
- *  Search for nodes which are ports, and force them to be breakpoints
+ *  Search through the list of node drivers and sinks (connections up
- *  in the "resInfo" field of their respective tiles in ResUse.  This
+ *  and down in the hierarchy), and make sure this information is
- *  ensures that connected nodes that stretch between two ports will
+ *  copied to the resInfo record of the tile(s) found at the connection.
- *  not be assumed to be "hanging" nodes.
  *
- *  Do the same thing for labels.
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Adds information to the resInfo clientData of tiles in def.
  *
  *----------------------------------------------------------------------------
  */
+
 void
-ResMakePortBreakpoints(def)
+ResMakeDriverSinkPorts(def)
     CellDef *def;
 {
     Plane	*plane;
@@ -201,21 +235,66 @@ ResMakePortBreakpoints(def)
     HashSearch  hs;
     HashEntry   *entry;
     ResExtNode  *node;
-    int ResAddBreakpointFunc();	/* Forward Declaration */
+    ResConnect  *rdriver, *rsink;
+    DriverSinkData dsd;
+    int ResAddPortFunc();	/* Forward Declaration */
 
     HashStartSearch(&hs);
     while((entry = HashNext(&ResNodeTable, &hs)) != NULL)
     {
 	node = (ResExtNode *)HashGetValue(entry);
-	if (node->status & PORTNODE)
+
+	for (rdriver = node->drivepoints; rdriver; rdriver = rdriver->rc_next)
 	{
-	    if (node->rs_ttype <= 0)
+	    if (rdriver->rc_type <= 0)
 	    {
 		TxError("Warning:  Label \"%s\" is unconnected.\n", node->name);
 		continue;
 	    }
 
-	    rect  = &(node->rs_bbox);
+	    rect = &(rdriver->rc_rect);
+
+	    /* If label is on a contact, the contact has been dissolved. */
+	    /* Assume that the uppermost residue is the port.  This may	 */
+	    /* not necessarily be the case.  Could do a boundary scan on */
+	    /* each residue plane to see which side of the contact is	 */
+	    /* the internal connection in the def. . .			 */
+
+	    if (DBIsContact(rdriver->rc_type))
+	    {
+		TileType type;
+
+		DBFullResidueMask(rdriver->rc_type, &mask);
+		for (type = DBNumUserLayers - 1; type >= TT_TECHDEPBASE; type--)
+		    if (TTMaskHasType(&mask, type))
+		    {
+			plane = def->cd_planes[DBPlane(type)];
+			break;
+		    }
+	    }
+	    else
+	    {
+		TTMaskSetOnlyType(&mask, rdriver->rc_type);
+		plane = def->cd_planes[DBPlane(rdriver->rc_type)];
+	    }
+
+	    dsd.dsd_connect = rdriver;
+	    dsd.dsd_node = node;
+	    (void) DBSrPaintArea((Tile *) NULL, plane, rect, &mask,
+			ResAddPortFunc, (ClientData)&dsd);
+	}
+
+	/* Process sink points in the same way */
+
+	for (rsink = node->sinkpoints; rsink; rsink = rsink->rc_next)
+	{
+	    if (rsink->rc_type <= 0)
+	    {
+		TxError("Warning:  Label \"%s\" is unconnected.\n", node->name);
+		continue;
+	    }
+
+	    rect = &(rsink->rc_rect);
 
 	    /* Beware of zero-area ports */
 	    if (rect->r_xbot == rect->r_xtop)
@@ -235,11 +314,11 @@ ResMakePortBreakpoints(def)
 	    /* each residue plane to see which side of the contact is	 */
 	    /* the internal connection in the def. . .			 */
 
-	    if (DBIsContact(node->rs_ttype))
+	    if (DBIsContact(rsink->rc_type))
 	    {
 		TileType type;
 
-		DBFullResidueMask(node->rs_ttype, &mask);
+		DBFullResidueMask(rsink->rc_type, &mask);
 		for (type = DBNumUserLayers - 1; type >= TT_TECHDEPBASE; type--)
 		    if (TTMaskHasType(&mask, type))
 		    {
@@ -249,40 +328,122 @@ ResMakePortBreakpoints(def)
 	    }
 	    else
 	    {
-		TTMaskSetOnlyType(&mask, node->rs_ttype);
+		TTMaskSetOnlyType(&mask, rsink->rc_type);
-		plane = def->cd_planes[DBPlane(node->rs_ttype)];
+		plane = def->cd_planes[DBPlane(rsink->rc_type)];
 	    }
 
+	    dsd.dsd_connect = rsink;
+	    dsd.dsd_node = node;
 	    (void) DBSrPaintArea((Tile *) NULL, plane, rect, &mask,
-			ResAddBreakpointFunc, (ClientData)node);
+			ResAddPortFunc, (ClientData)&dsd);
 	}
     }
 }
 
 /*
- *---------------------------------------------------------------------------
+ *----------------------------------------------------------------------------
  *
- *  ResMakeLabelBreakpoints --
+ * ResAddPortFunc --
  *
- *  Search for labels that are part of a node, and force them to be
+ *	Add a portList entry to the "resInfo" structure of the tile.  The
- *  breakpoints in the "resInfo" field of their respective tiles in
+ *	portList entry keeps a record of the area of overlap or abutment
- *  ResUse.  This ensures (among other things) that pins of a top level
+ *	of the port, as well as a pointer to the resNode.
- *  cell will be retained and become the endpoint of a net.
+ *
+ * Results:
+ *	Always returns 0;
+ *
+ * Side effects:
+ *	Adds information to a tile's "resInfo" clientData.
  *
  *----------------------------------------------------------------------------
  */
+
+int
+ResAddPortFunc(tile, dinfo, dsd)
+    Tile *tile;
+    TileType dinfo;		/* (unused) */
+    DriverSinkData *dsd;	/* Data for driver or sink */
+{
+    resPort *rp;
+    resInfo *pX;
+    Rect rect;
+    ResConnect *connect;
+    ResExtNode *node;
+
+    if (TiGetClient(tile) == CLIENTDEFAULT)
+	return 0;
+
+    /* To simplify processing, if a split tile does not have TT_SPACE
+     * on either side, then only the left side is processed.
+     */
+    if (IsSplit(tile))
+	if (TiGetLeftType(tile) != TT_SPACE && TiGetRightType(tile) != TT_SPACE)
+	    if (dinfo & TT_SIDE)
+		return 0;
+
+    node = dsd->dsd_node;
+    connect = dsd->dsd_connect;
+
+    TiToRect(tile, &rect);
+
+    pX = (resInfo *)TiGetClient(tile);
+
+    rp = (resPort *) mallocMagic((unsigned)(sizeof(resPort)));
+    rp->rp_nextPort = pX->portList;
+    rp->rp_bbox = connect->rc_rect;
+    rp->rp_loc = connect->rc_rect.r_ll;
+    rp->rp_connect = connect;
+    rp->rp_nodename = node->name;
+    pX->portList = rp;
+
+    return 0;
+}
+
+/* Structure used by ResMakeLabelPorts() to pass information to
+ * ResAddPortFunc().  Contains a reference to a node, so that the
+ * link between the tile and the node can be maintained, and the
+ * label, which has the information about the position and tile
+ * type of the label.
+ */
+
+typedef struct reslabeldata {
+    ResExtNode	*rld_node;
+    Label	*rld_label;
+    ResConnect  *rld_connect;
+} ResLabelData;
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * ResMakeLabelPorts --
+ *
+ *  Search for labels that are part of a node, and add them to the
+ *  portList linked list in the "resInfo" field of their respective tiles
+ *  in ResUse.  This ensures (among other things) that pins of a top level
+ *  cell will be retained and become the endpoint of a net.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Adds information to the resInfo clientData of tiles in def.
+ *
+ *----------------------------------------------------------------------------
+ */
+
 void
-ResMakeLabelBreakpoints(def, resisdata)
+ResMakeLabelPorts(def, resisdata)
     CellDef 	*def;
     ResisData   *resisdata;
 {
     Plane	*plane;
-    Rect	*rect;
     TileTypeBitMask mask;
     HashEntry   *entry;
     ResExtNode  *node;
+    ResConnect  *rdriver, *newsink;
     Label	*slab;
-    int ResAddBreakpointFunc();	/* Forward Declaration */
+    ResLabelData rld;
+    int ResAddLabelFunc();	/* Forward Declaration */
 
     for (slab = def->cd_labels; slab != NULL; slab = slab->lab_next)
     {
@@ -293,20 +454,26 @@ ResMakeLabelBreakpoints(def, resisdata)
 	entry = HashFind(&ResNodeTable, slab->lab_text);
 	node = ResExtInitNode(entry);
 
-	/* If the drivepoint position changes and the drivepoint is	*/
+	/* If there is an existing drivepoint at this location,	*/
-	/* in the "resisdata" record, then make sure the tile type	*/
+	/* then ignore it.					*/
-	/* in "resisdata" gets changed to match.			*/
 
-	if (resisdata->rg_devloc == &node->drivepoint)
+	for (rdriver = node->drivepoints; rdriver; rdriver = rdriver->rc_next)
+	{
+	    if (GEO_TOUCH(&slab->lab_rect, &rdriver->rc_rect))
+		break;
+	}
+	if (rdriver != NULL) break;
+
+	/* Add a new sinkpoint to the node where the label is */
+	newsink = (ResConnect *)mallocMagic(sizeof(ResConnect));
+	newsink->rc_next = node->sinkpoints;
+	node->sinkpoints = newsink;
+
+	if (GEO_ENCLOSE(resisdata->rg_devloc, &slab->lab_rect))
 	    resisdata->rg_ttype = slab->lab_type;
 
-        node->drivepoint = slab->lab_rect.r_ll;
+        newsink->rc_rect = slab->lab_rect;
-        node->rs_bbox = slab->lab_rect;
+        newsink->rc_type = slab->lab_type;
-        node->location = slab->lab_rect.r_ll;
-        node->rs_ttype = slab->lab_type;
-        node->type = slab->lab_type;
-
-	rect = &(node->rs_bbox);
 
 	/* If label is on a contact, the contact has been dissolved.	*/
 	/* Assume that the uppermost residue is the port.  This may	*/
@@ -332,29 +499,44 @@ ResMakeLabelBreakpoints(def, resisdata)
 		plane = def->cd_planes[DBPlane(slab->lab_type)];
 	}
 
-	(void) DBSrPaintArea((Tile *) NULL, plane, rect, &mask,
+	rld.rld_node = node;
-			ResAddBreakpointFunc, (ClientData)node);
+	rld.rld_label = slab;
-
+	rld.rld_connect = newsink;
+	(void) DBSrPaintArea((Tile *) NULL, plane, &newsink->rc_rect, &mask,
+			ResAddLabelFunc, (ClientData)&rld);
     }
 }
 
 /*
  *----------------------------------------------------------------------------
  *
- * ResAddBreakpointFunc --
+ * ResAddLabelFunc --
  *
- *	Add a breakpoint to the "resInfo" structure of the tile
+ *	Add a portList entry to the "resInfo" structure of the tile.  The
+ *	portList entry keeps a record of the area of overlap or abutment
+ *	of the port, as well as a pointer to the resNode.
+ *
+ * Results:
+ *	Always returns 0;
+ *
+ * Side effects:
+ *	Adds information to a tile's "resInfo" clientData.
  *
  *----------------------------------------------------------------------------
  */
 
 int
-ResAddBreakpointFunc(tile, dinfo, node)
+ResAddLabelFunc(tile, dinfo, rld)
     Tile *tile;
     TileType dinfo;		/* (unused) */
-   ResExtNode *node;
+    ResLabelData *rld;		/* Label and node data */
 {
-    resInfo *info;
+    resPort *rp;
+    resInfo *pX;
+    Rect rect;
+    Label *label;
+    ResExtNode *node;
+    ResConnect *connect;
 
     if (TiGetClient(tile) == CLIENTDEFAULT)
 	return 0;
@@ -367,24 +549,38 @@ ResAddBreakpointFunc(tile, dinfo, node)
 	    if (dinfo & TT_SIDE)
 		return 0;
 
-    NEWPORT(node, tile);
+    node = rld->rld_node;
+    label = rld->rld_label;
+    connect = rld->rld_connect;
+
+    TiToRect(tile, &rect);
+
+    pX = (resInfo *)TiGetClient(tile);
+
+    rp = (resPort *) mallocMagic((unsigned)(sizeof(resPort)));
+    rp->rp_nextPort = pX->portList;
+    rp->rp_bbox = label->lab_rect;
+    rp->rp_loc = label->lab_rect.r_ll;
+    rp->rp_connect = connect;
+    rp->rp_nodename = node->name;
+    pX->portList = rp;
 
     return 0;
 }
 
-
 /*
  *---------------------------------------------------------------------------
  *
  *  ResFindNewContactTiles --
  *
+ * Dissolving contacts eliminated the tiles that contacts->nextcontact
+ * pointed to.  This procedure finds the tile now under center and sets
+ * that tile's ti_client field to point to the contact.  The old value
+ * of clientdata is set to nextTilecontact.
  *
  *  Results:  none
  *
- *  Side Effects:  dissolving contacts eliminated the tiles that
+ *  Side Effects:  modifies information in the contact records.
- *  contacts->nextcontact pointed to. This procedure finds the tile now under
- *  center and sets that tile's ti_client field to point to the contact.  The
- *  old value of clientdata is set to nextTilecontact.
  *
  *----------------------------------------------------------------------------
  */
@@ -396,9 +592,14 @@ ResFindNewContactTiles(contacts)
     int pNum;
     Tile *tile;
     TileTypeBitMask mask;
+    TileType lastType = TT_SPACE;
 
     for (; contacts != (ResContactPoint *) NULL; contacts = contacts->cp_nextcontact)
     {
+	/* Avoid re-running the following code for the same contact type */
+	if (contacts->cp_type != lastType)
+	{
+	    lastType = contacts->cp_type;
 	    DBFullResidueMask(contacts->cp_type, &mask);
 
 	    /* Watch for types that connect to the substrate plane or well;	*/
@@ -414,11 +615,17 @@ ResFindNewContactTiles(contacts)
 		if (!TTMaskIsZero(&cMask))
 		    TTMaskSetMask(&mask, &cMask);
 	    }
+	}
 	
      	for (pNum = PL_TECHDEPBASE; pNum < DBNumPlanes; pNum++)
 	{
+	    if (!DBTypeOnPlane(contacts->cp_type, pNum) &&
+			(pNum != ExtCurStyle->exts_globSubstratePlane))
+		continue;
+
 	    tile = PlaneGetHint(ResDef->cd_planes[pNum]);
 	    GOTOPOINT(tile, &(contacts->cp_center));
+	    PlaneSetHint(ResDef->cd_planes[pNum], tile);
 #ifdef PARANOID
 	    if (tile == (Tile *) NULL)
 	    {
@@ -476,10 +683,11 @@ ResFindNewContactTiles(contacts)
 /*
  *--------------------------------------------------------------------------
  *
- * ResProcessTiles--Calls ResEachTile with processed tiles belonging to
+ * ResProcessTiles --
- *		nodes in ResNodeQueue.  When all the tiles corresponding
+ *
- *		to a node have been processed, the node is moved to
+ * Calls ResEachTile with processed tiles belonging to nodes in ResNodeQueue.
- *		ResNodeList.
+ * When all the tiles corresponding to a node have been processed, the node
+ * is moved to ResNodeList.
  *
  *  Results:  Return 1 if any error occurred, 0 otherwise.
  *
@@ -490,8 +698,8 @@ ResFindNewContactTiles(contacts)
 
 int
 ResProcessTiles(resisdata, origin)
-    Point	*origin;
     ResisData	*resisdata;
+    Point	*origin;
 
 {
     Tile 	*startTile;
@@ -509,7 +717,8 @@ ResProcessTiles(resisdata, origin)
         if (startTile == NULL)
 	    return 1;
 	resCurrentNode = NULL;
-	(void) ResEachTile(startTile, origin);
+	ResStartTile(startTile, origin->p_x, origin->p_y);
+	(void) ResEachTile(startTile);
     }
 #ifdef PARANOID
     else
@@ -546,7 +755,7 @@ ResProcessTiles(resisdata, origin)
 		    if ((ri->ri_status & RES_TILE_DONE) == 0)
 		    {
 			resCurrentNode = resptr2;
-			merged |= ResEachTile(tile, (Point *)NULL);
+			merged |= ResEachTile(tile);
 		    }
 		}
 		rj->rj_status = TRUE;
@@ -572,7 +781,7 @@ ResProcessTiles(resisdata, origin)
 			if (cp->cp_cnode[tilenum] == resptr2)
 			{
 			    resCurrentNode = resptr2;
-			    merged |= ResEachTile(tile, (Point *)NULL);
+			    merged |= ResEachTile(tile);
 			}
 			else
 			{
@@ -655,7 +864,7 @@ ResCalcPerimOverlap(tile, dev)
     }
 
     /* right */
-    for (tp = TR(tile); TOP(tp) > BOTTOM(tile); tp=LB(tp))
+    for (tp = TR(tile); TOP(tp) > BOTTOM(tile); tp = LB(tp))
     {
 	if TTMaskHasType(omask, TiGetLeftType(tp))
 	    overlap += MIN(TOP(tile), TOP(tp)) - MAX(BOTTOM(tile), BOTTOM(tp));
@@ -669,7 +878,7 @@ ResCalcPerimOverlap(tile, dev)
     }
 
     /* bottom */
-    for (tp = LB(tile); LEFT(tp) < RIGHT(tile); tp=TR(tp))
+    for (tp = LB(tile); LEFT(tp) < RIGHT(tile); tp = TR(tp))
     {
 	if TTMaskHasType(omask, TiGetTopType(tp))
 	      overlap += MIN(RIGHT(tile), RIGHT(tp)) - MAX(LEFT(tile), LEFT(tp));
@@ -1054,15 +1263,22 @@ ResExtractNet(node, resisdata, cellname)
 
     /* Copy Paint */
 
-    /* If the node location is INFINITY, then use the rs_bbox */
+    /* If the node location is INFINITY, then use the first drivepoint */
 
     if ((node->location.p_x == INFINITY) || (node->location.p_y == INFINITY))
     {
-	scx.scx_area.r_ll.p_x = node->rs_bbox.r_xbot;
+	ResConnect *rdriver = node->drivepoints;
-	scx.scx_area.r_ll.p_y = node->rs_bbox.r_ybot;
+	if (rdriver)
-	scx.scx_area.r_ur.p_x = node->rs_bbox.r_xtop;
+	{
-	scx.scx_area.r_ur.p_y = node->rs_bbox.r_ytop;
+	    scx.scx_area.r_ll.p_x = rdriver->rc_rect.r_xbot - 2;
-	startpoint = node->drivepoint;
+	    scx.scx_area.r_ll.p_y = rdriver->rc_rect.r_ybot - 2;
+	    scx.scx_area.r_ur.p_x = rdriver->rc_rect.r_xtop + 2;
+	    scx.scx_area.r_ur.p_y = rdriver->rc_rect.r_ytop + 2;
+	    startpoint.p_x = (rdriver->rc_rect.r_xtop + rdriver->rc_rect.r_xbot) / 2;
+	    startpoint.p_y = (rdriver->rc_rect.r_ytop + rdriver->rc_rect.r_ybot) / 2;
+	}
+	else
+	    TxError("Internal error:  Node location is set to infinity.\n");
     }
     else
     {
@@ -1085,13 +1301,40 @@ ResExtractNet(node, resisdata, cellname)
 	DBTreeCopyConnect(&scx, &FirstTileMask, 0, ResCopyMask, &TiPlaneRect,
 					SEL_DO_LABELS, ResUse);
     }
+    else if (node->drivepoints)
+    {
+	/* Use the first valid drivepoint */
+	ResConnect *drivepoint = node->drivepoints;
+	while (drivepoint && (drivepoint->rc_type == TT_SPACE))
+	    drivepoint = drivepoint->rc_next;
+	if (drivepoint)
+	{
+	    TTMaskZero(&FirstTileMask);
+	    TTMaskSetMask(&FirstTileMask, &DBConnectTbl[drivepoint->rc_type]);
 
-    TTMaskZero(&ResSDTypesBitMask);
+	    DBTreeCopyConnect(&scx, &FirstTileMask, 0, ResCopyMask, &TiPlaneRect,
+					SEL_DO_LABELS, ResUse);
+	}
+	else
+	{
+	    TxError("Node %s:  Did not find the net layout at any drivepoint.\n",
+			node->name);
+	    return TRUE;
+	}
+    }
+    else
+    {
+	TxError("Node %s:  Did not find the net layout at node location (%d %d).\n",
+		node->name, node->location.p_x, node->location.p_y);
+	return TRUE;
+    }
+
+    TTMaskZero(&ResTermTypesBitMask);
     TTMaskZero(&ResSubTypesBitMask);
 
     /* Add devices to ResUse from list in node */
     DevTiles = NULL;
-    for (tptr = node->firstDev; tptr; tptr = tptr->nextDev)
+    for (tptr = node->devices; tptr; tptr = tptr->nextDev)
     {
 	int result;
 	int i;
@@ -1123,13 +1366,13 @@ ResExtractNet(node, resisdata, cellname)
 	TTMaskSetOnlyType(&tMask, thisDev->type);
 	DBTreeSrTiles(&scx, &tMask, 0, resExpandDevFunc, (ClientData)thisDev);
 
-	/* If the device has source/drain types in a different plane than   */
+	/* If the device has terminal types in a different plane than	*/
-	/* the device identifier type, then add the source/drain types to   */
+	/* the device identifier type, then add the terminal types to	*/
-	/* the mask ResSDTypesBitMask.					    */
+	/* the mask ResTermTypesBitMask.				*/
 
 	devptr = tptr->thisDev->rs_devptr;
 	for (i = 0; !TTMaskIsZero(&devptr->exts_deviceSDTypes[i]); i++)
-	    TTMaskSetMask(&ResSDTypesBitMask, &devptr->exts_deviceSDTypes[i]);
+	    TTMaskSetMask(&ResTermTypesBitMask, &devptr->exts_deviceSDTypes[i]);
 
 	/* Add the substrate types to the mask ResSubTypesBitMask	    */
 	TTMaskSetMask(&ResSubTypesBitMask, &devptr->exts_deviceSubstrateTypes);
@@ -1139,8 +1382,6 @@ ResExtractNet(node, resisdata, cellname)
     }
     DBReComputeBbox(ResUse->cu_def);
 
-    ExtResetTiles(scx.scx_use->cu_def, CLIENTDEFAULT);
-
     /* To avoid issues with overlapping stacked contact types and	*/
     /* double-counting contacts on multiple planes, erase the top	*/
     /* contact layers of all contacts.  ExtFindRegions() will still	*/
@@ -1195,8 +1436,8 @@ ResExtractNet(node, resisdata, cellname)
      * cell.
      */
 
-    ResMakePortBreakpoints(ResUse->cu_def);
+    ResMakeDriverSinkPorts(ResUse->cu_def);
-    ResMakeLabelBreakpoints(ResUse->cu_def, resisdata);
+    ResMakeLabelPorts(ResUse->cu_def, resisdata);
 
     /* Finish preprocessing. */
 
@@ -1381,6 +1622,7 @@ FindStartTile(resisdata, SourcePoint)
     {
 	tile = PlaneGetHint(ResUse->cu_def->cd_planes[pnum]);
 	GOTOPOINT(tile, &workingPoint);
+	PlaneSetHint(ResUse->cu_def->cd_planes[pnum], tile);
 	SourcePoint->p_x = workingPoint.p_x;
 	SourcePoint->p_y = workingPoint.p_y;
 
@@ -1395,13 +1637,13 @@ FindStartTile(resisdata, SourcePoint)
 
 	    if (workingPoint.p_x == LEFT(tile))
 	    {
-		for (tp = BL(tile); BOTTOM(tp) < TOP(tile); tp=RT(tp))
+		for (tp = BL(tile); BOTTOM(tp) < TOP(tile); tp = RT(tp))
 		    if (TiGetRightType(tp) == resisdata->rg_ttype)
 			return(tp);
 	    }
 	    else if (workingPoint.p_y == BOTTOM(tile))
 	    {
-		for (tp = LB(tile); LEFT(tp) < RIGHT(tile); tp=TR(tp))
+		for (tp = LB(tile); LEFT(tp) < RIGHT(tile); tp = TR(tp))
 		    if (TiGetTopType(tp) == resisdata->rg_ttype)
 			return(tp);
 	    }
@@ -1414,6 +1656,7 @@ FindStartTile(resisdata, SourcePoint)
 
     tile = PlaneGetHint(ResUse->cu_def->cd_planes[pnum]);
     GOTOPOINT(tile, &workingPoint);
+    PlaneSetHint(ResUse->cu_def->cd_planes[pnum], tile);
 
     if (IsSplit(tile))
     {
@@ -1457,7 +1700,7 @@ FindStartTile(resisdata, SourcePoint)
 			TTMaskHasType(&(devptr->exts_deviceSDTypes[i]), t2))
 		{
 		    SourcePoint->p_x = LEFT(tile);
-		    SourcePoint->p_y = (MIN(TOP(tile),TOP(tp)) +
+		    SourcePoint->p_y = (MIN(TOP(tile), TOP(tp)) +
 		   			MAX(BOTTOM(tile), BOTTOM(tp))) >> 1;
 		    return(tp);
 		}
@@ -1500,7 +1743,7 @@ FindStartTile(resisdata, SourcePoint)
 			TTMaskHasType(&(devptr->exts_deviceSDTypes[i]), t2))
 		{
 		    SourcePoint->p_y = TOP(tile);
-		    SourcePoint->p_x = (MIN(RIGHT(tile),RIGHT(tp)) +
+		    SourcePoint->p_x = (MIN(RIGHT(tile), RIGHT(tp)) +
 		   			MAX(LEFT(tile), LEFT(tp))) >> 1;
 		    return(tp);
 		}
@@ -1556,7 +1799,7 @@ FindStartTile(resisdata, SourcePoint)
 				TTMaskHasType(&(devptr->exts_deviceSDTypes[i]), t2))
 			{
 			    SourcePoint->p_x = LEFT(tile);
-			    SourcePoint->p_y = (MIN(TOP(tile),TOP(tp)) +
+			    SourcePoint->p_y = (MIN(TOP(tile), TOP(tp)) +
 		   			MAX(BOTTOM(tile), BOTTOM(tp))) >> 1;
 			    while (!StackEmpty(devStack))
 			    {
@@ -1624,7 +1867,7 @@ FindStartTile(resisdata, SourcePoint)
 				TTMaskHasType(&(devptr->exts_deviceSDTypes[i]), t2))
 			{
 			    SourcePoint->p_y = TOP(tile);
-			    SourcePoint->p_x = (MIN(RIGHT(tile),RIGHT(tp)) +
+			    SourcePoint->p_x = (MIN(RIGHT(tile), RIGHT(tp)) +
 			   			MAX(LEFT(tile), LEFT(tp))) >> 1;
 			    while (!StackEmpty(devStack))
 			    {
@@ -1765,6 +2008,7 @@ ResGetDevice(pt, type)
 
     tile = PlaneGetHint(ResUse->cu_def->cd_planes[pnum]);
     GOTOPOINT(tile, &workingPoint);
+    PlaneSetHint(ResUse->cu_def->cd_planes[pnum], tile);
 
     const ClientData ticlient = TiGetClient(tile);
     if (IsSplit(tile))

resis/ResMakeRes.c

@@ -76,11 +76,10 @@ ResCalcTileResistance(tile, info, pendingList, doneList)
 	if (x < MinX) MinX = x;
 	if (y > MaxY) MaxY = y;
 	if (y < MinY) MinY = y;
+
 	if (p1->br_this->rn_why == RES_NODE_DEVICE)
-	{
 	    device = TRUE;
     }
-    }
 
     /* Finally, produce resistors for partition. Keep track of	*/
     /* whether or not the node was involved in a merge.		*/
@@ -125,7 +124,7 @@ ResCalcEastWest(tile, pendingList, doneList, resList)
     resNode	**pendingList, **doneList;
     resResistor	**resList;
 {
-    int 	height;
+    int 	count, height;
     bool	merged;
     TileType	ttype;
     Breakpoint	*p1, *p2, *p3;
@@ -134,6 +133,8 @@ ResCalcEastWest(tile, pendingList, doneList, resList)
     resNode	*currNode;
     float	rArea;
     resInfo	*info = (resInfo *)TiGetClientPTR(tile);
+    HashTable	BreakTable;
+    HashEntry	*he;
 
     merged = FALSE;
     height = TOP(tile) - BOTTOM(tile);
@@ -163,21 +164,38 @@ ResCalcEastWest(tile, pendingList, doneList, resList)
 	ttype = TiGetTypeExact(tile);
 
     /* Re-sort nodes left to right. */
+    count = ResSortBreaks(&info->breakList, TRUE);
 
-    ResSortBreaks(&info->breakList, TRUE);
+    /* For long lists (defined as >= 16 entries), make a hash table of
+     * the node pointer conversions so that each node can be updated
+     * as we walk the list, instead of walking the rest of the list in
+     * a nested loop for each entry.
+     */
+    if (count >= 16)
+	HashInit(&BreakTable, HT_DEFAULTSIZE, HT_CLIENTKEYS);
 
     /*
      * Eliminate breakpoints with the same X coordinate and merge
      * their nodes.
      */
 
-    p2= info->breakList;
+    p2 = info->breakList;
 
     /* Add extra left area to leftmost node */
 
     p2->br_this->rn_float.rn_area += height * (p2->br_loc.p_x - LEFT(tile));
     while (p2->br_next != NULL)
     {
+	/* Has the node been recorded as needing to be replaced? */
+	if (count >= 16)
+	{
+	    while (TRUE)
+	    {
+		he = HashLookOnly(&BreakTable, (char *)p2->br_this);
+		if (!he) break;
+		p2->br_this = (resNode *)HashGetValue(he);
+	    }
+	}
 	p1 = p2;
 	p2 = p2->br_next;
 	if (p2->br_loc.p_x == p1->br_loc.p_x)
@@ -215,8 +233,20 @@ ResCalcEastWest(tile, pendingList, doneList, resList)
 	    /*
 	     * Was the node used in another info or breakpoint?
 	     * If so, replace the old node with the new one.
+	     *
+	     * Short lists:  Walk the list to the end and change
+	     * nodes on the fly.
+	     * Long lists:  Record the change to be made in the
+	     * hash table so that it can be executed as each list
+	     * entry is encountered.
 	     */
-
+	    if (count >= 16)
+	    {
+		he = HashFind(&BreakTable, (char *)currNode);
+		HashSetValue(he, (char *)p2->br_this);
+	    }
+	    else
+	    {
 		p3 = p2->br_next;
 		while (p3 != NULL)
 		{
@@ -226,6 +256,7 @@ ResCalcEastWest(tile, pendingList, doneList, resList)
 		    p3 = p3->br_next;
 		}
 	    }
+	}
 
 	/*
 	 * If the X coordinates don't match, make a resistor between
@@ -276,6 +307,8 @@ ResCalcEastWest(tile, pendingList, doneList, resList)
 	}
     }
 
+    if (count >= 16) HashKill(&BreakTable);
+
     p2->br_this->rn_float.rn_area += height * (RIGHT(tile) - p2->br_loc.p_x);
     freeMagic((char *)p2);
     info->breakList = NULL;
@@ -301,7 +334,7 @@ ResCalcNorthSouth(tile, pendingList, doneList, resList)
     resNode	**pendingList, **doneList;
     resResistor	**resList;
 {
-    int 	width;
+    int 	count, width;
     bool	merged;
     TileType	ttype;
     Breakpoint	*p1, *p2, *p3;
@@ -310,6 +343,8 @@ ResCalcNorthSouth(tile, pendingList, doneList, resList)
     resNode	*currNode;
     float	rArea;
     resInfo	*info = (resInfo *)TiGetClientPTR(tile);
+    HashTable	BreakTable;
+    HashEntry	*he;
 
     merged = FALSE;
     width = RIGHT(tile) - LEFT(tile);
@@ -329,7 +364,15 @@ ResCalcNorthSouth(tile, pendingList, doneList, resList)
     }
 
     /* Re-sort nodes south to north. */
-    ResSortBreaks(&info->breakList, FALSE);
+    count = ResSortBreaks(&info->breakList, FALSE);
+
+    /* For long lists (defined as >= 16 entries), make a hash table of
+     * the node pointer conversions so that each node can be updated
+     * as we walk the list, instead of walking the rest of the list in
+     * a nested loop for each entry.
+     */
+    if (count >= 16)
+	HashInit(&BreakTable, HT_DEFAULTSIZE, HT_CLIENTKEYS);
 
     /* Simplified split tile handling */
     if (IsSplit(tile))
@@ -353,6 +396,16 @@ ResCalcNorthSouth(tile, pendingList, doneList, resList)
     p2->br_this->rn_float.rn_area += width * (p2->br_loc.p_y - BOTTOM(tile));
     while (p2->br_next != NULL)
     {
+	/* Has the node been recorded as needing to be replaced? */
+	if (count >= 16)
+	{
+	    while (TRUE)
+	    {
+		he = HashLookOnly(&BreakTable, (char *)p2->br_this);
+		if (!he) break;
+		p2->br_this = (resNode *)HashGetValue(he);
+	    }
+	}
 	p1 = p2;
 	p2 = p2->br_next;
 	if (p1->br_loc.p_y == p2->br_loc.p_y)
@@ -390,7 +443,20 @@ ResCalcNorthSouth(tile, pendingList, doneList, resList)
 	    /*
 	     * Was the node used in another info or breakpoint?
 	     * If so, replace the old node with the new one.
+	     *
+	     * Short lists:  Walk the list to the end and change
+	     * nodes on the fly.
+	     * Long lists:  Record the change to be made in the
+	     * hash table so that it can be executed as each list
+	     * entry is encountered.
 	     */
+	    if (count >= 16)
+	    {
+		he = HashFind(&BreakTable, (char *)currNode);
+		HashSetValue(he, (char *)p2->br_this);
+	    }
+	    else
+	    {
 		p3 = p2->br_next;
 		while (p3 != NULL)
 		{
@@ -400,6 +466,7 @@ ResCalcNorthSouth(tile, pendingList, doneList, resList)
 		    p3 = p3->br_next;
 		}
 	    }
+	}
 
 	/*
 	 * If the Y coordinates don't match, make a resistor between
@@ -525,7 +592,7 @@ ResCalcNearDevice(tile, pendingList, doneList, resList)
         (devedge & TOPEDGE) == devedge 	||
         (devedge & BOTTOMEDGE) == devedge)
     {
-	ResSortBreaks(&info->breakList,TRUE);
+	ResSortBreaks(&info->breakList, TRUE);
         p2 = NULL;
         for (p1 = info->breakList; p1 != NULL; p1 = p1->br_next)
         {
@@ -620,7 +687,7 @@ ResCalcNearDevice(tile, pendingList, doneList, resList)
 		}
 		else
 		{
-		    deltay=0;
+		    deltay = 0;
 		}
 	    }
 	    else
@@ -634,15 +701,15 @@ ResCalcNearDevice(tile, pendingList, doneList, resList)
 	    {
 	       	if (p2->br_crect->r_ll.p_y > p1->br_loc.p_y)
 		{
-		    deltay = MIN(deltay,p2->br_crect->r_ll.p_y - p1->br_loc.p_y);
+		    deltay = MIN(deltay, p2->br_crect->r_ll.p_y - p1->br_loc.p_y);
 		}
 	       	else if (p2->br_crect->r_ur.p_y < p1->br_loc.p_y)
 		{
-		    deltay = MIN(deltay,p1->br_loc.p_y - p2->br_crect->r_ur.p_y);
+		    deltay = MIN(deltay, p1->br_loc.p_y - p2->br_crect->r_ur.p_y);
 		}
 		else
 		{
-		    deltay=0;
+		    deltay = 0;
 		}
 	    }
 	    else
@@ -820,7 +887,7 @@ ResDoContacts(contact, nodes, resList)
 	    Tile *tile = contact->cp_tile[tilenum];
 
 	    contact->cp_cnode[tilenum] = resptr;
-	    NEWBREAK(resptr, tile, contact->cp_center.p_x,
+	    ResNewBreak(resptr, tile, contact->cp_center.p_x,
 			contact->cp_center.p_y, &contact->cp_rect);
         }
     }
@@ -869,7 +936,7 @@ ResDoContacts(contact, nodes, resList)
 	    ccell->ce_thisc = contact;
 
 	    contact->cp_cnode[tilenum] = resptr;
-	    NEWBREAK(resptr, tile, contact->cp_center.p_x,
+	    ResNewBreak(resptr, tile, contact->cp_center.p_x,
 			contact->cp_center.p_y, &contact->cp_rect);
 
 	    /* Add resistors here */
@@ -919,21 +986,207 @@ ResDoContacts(contact, nodes, resList)
 /*
  *-------------------------------------------------------------------------
  *
- * ResSortBreaks --
+ * BreakCompare --
+ *
+ *	Helper routine for MergeSortBreaks() (below).  Simple
+ *	comparison of the breakpoint position.  Comparison is
+ *	done for the X position if "xsort" is TRUE, and the Y
+ *	position if "xsort" is FALSE.
+ *
+ * Return value:
+ *	Return -1 if the (x or y) position of a is less than the
+ *	(x or y) position of b;  return +1 if the position of a is
+ *	greater than the position of b;  and return 0 if they have
+ *	equal positions.
+ *
+ * Side effect:
+ *	None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+int
+BreakCompare(
+    Breakpoint *a,
+    Breakpoint *b,
+    int xsort)
+{
+    if (xsort == TRUE)
+    {
+	if (a->br_loc.p_x < b->br_loc.p_x) return -1;
+	if (a->br_loc.p_x > b->br_loc.p_x) return 1;
+    }
+    else
+    {
+	if (a->br_loc.p_y < b->br_loc.p_y) return -1;
+	if (a->br_loc.p_y > b->br_loc.p_y) return 1;
+    }
+    return 0;
+}
+
+/*
+ *-------------------------------------------------------------------------
+ *
+ * MergeSorted --
+ *
+ *	Helper routine for MergeSortBreaks() (below).  Merge sort
+ *	merging routine.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+Breakpoint *
+MergeSorted(
+    Breakpoint *a,
+    Breakpoint *b,
+    int xsort)
+{
+    Breakpoint head;
+    Breakpoint *tail = &head;
+
+    head.br_next = NULL;
+
+    while (a != NULL && b != NULL)
+    {
+	if (BreakCompare(a, b, xsort) <= 0)
+	{
+	    tail->br_next = a;
+	    a = a->br_next;
+	}
+	else
+	{
+	    tail->br_next = b;
+	    b = b->br_next;
+	}
+	tail = tail->br_next;
+    }
+    tail->br_next = (a != NULL) ? a : b;
+
+    return head.br_next;
+}
+
+/*
+ *-------------------------------------------------------------------------
+ *
+ * SplitList --
+ *
+ *	Helper routine for MergeSortBreaks() (below).  Merge sort
+ *	splitting routine.
  *
  * Results:
- *	None
+ *	None.
  *
  *-------------------------------------------------------------------------
  */
 
 void
+SplitList(
+    Breakpoint *source,
+    Breakpoint **front,
+    Breakpoint **back)
+{
+    Breakpoint *slow;
+    Breakpoint *fast;
+
+    if (source == NULL || source->br_next == NULL)
+    {
+	*front = source;
+	*back = NULL;
+	return;
+    }
+
+    slow = source;
+    fast = source->br_next;
+
+    while (fast != NULL)
+    {
+	fast = fast->br_next;
+
+	if (fast != NULL)
+	{
+	    slow = slow->br_next;
+	    fast = fast->br_next;
+	}
+    }
+
+    *front = source;
+    *back = slow->br_next;
+    slow->br_next = NULL;
+}
+
+/*
+ *-------------------------------------------------------------------------
+ *
+ * MergeSortBreaks --
+ *
+ *	See "ResSortBreaks" below.  Alternative to bubble sort for long
+ *	linked lists.
+ *
+ * Results:
+ *	Pointer to a sorted breakpoint list.
+ *
+ * Side effects:
+ *	The breakpoints are sorted.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+Breakpoint *
+MergeSortBreaks(Breakpoint *list, int xsort)
+{
+    Breakpoint *a, *b;
+
+    if (list == NULL || list->br_next == NULL)
+	return list;
+
+    SplitList(list, &a, &b);
+
+    a = MergeSortBreaks(a, xsort);
+    b = MergeSortBreaks(b, xsort);
+
+    return MergeSorted(a, b, xsort);
+}
+
+/*
+ *-------------------------------------------------------------------------
+ *
+ * ResSortBreaks --
+ *
+ *	Sort breakpoints, either in the X direction (if "xsort" is TRUE)
+ *	or in the Y direction (if "xsort" is FALSE).  For short lists
+ *	(< 16 elements), a simple bubble sort is used.  For larger lists,
+ *	a merge sort is used.  Most resistor networks are short, but
+ *	power/ground networks can be huge and cause a performance
+ *	bottleneck. 
+ *
+ * Results:
+ *	Return the length of the list (maximum truncated at 16) so that
+ *	the calling routine can determine if this is a long or a short
+ *	linked list and treat it accordingly.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+int
 ResSortBreaks(masterlist, xsort)
     Breakpoint	**masterlist;
     int		xsort;
 {
     Breakpoint	*p1, *p2, *p3, *p4;
     bool	changed;
+    int		count = 0;
+
+    for (p1 = *masterlist; p1; p1 = p1->br_next)
+    {
+	count++;
+	if (count > 16)
+	{
+	    *masterlist = MergeSortBreaks(*masterlist, xsort);
+	    return count;
+	}
+    }
+
+    /* Simple bubble sort */
 
     changed = TRUE;
     while (changed == TRUE)
@@ -970,5 +1223,6 @@ ResSortBreaks(masterlist, xsort)
 	    }
 	}
     }
+    return count;
 }
 

resis/ResMerge.c

@@ -26,7 +26,6 @@ extern void ResEliminateResistor();
 extern void ResCleanNode();
 extern void ResFixBreakPoint();
 
-
 /*
  *-------------------------------------------------------------------------
  *
@@ -211,7 +210,7 @@ ResFixParallel(elimResis, newResis)
  * ResSeriesCheck -- for nodes with no devices, sees if a series
  *	or loop combination is possible.
  *
- * Results: returns SINGLE,LOOP,or SERIES if succesful.
+ * Results: returns SINGLE, LOOP, or SERIES if succesful.
  *
  * Side Effects: may delete some nodes and resistors.
  *
@@ -406,13 +405,70 @@ ResSeriesCheck(resptr)
 int
 ResParallelCheck(resptr)
     resNode	*resptr;
-
 {
-    resResistor	*r1,*r2;
+    resResistor	*r1, *r2;
-    resNode	*resptr2,*resptr3;
+    resNode	*resptr2, *resptr3;
     int		status = UNTOUCHED;
     resElement	*rcell1, *rcell2;
 
+    int rcount = 0;
+
+    /* When the number of resistors gets to be large enough, it is more efficient to
+     * sort the resistor list and then do a single pass to see if any two consecutive
+     * items in the sorted list can be merged, than to do a double loop through the
+     * resistor list at ~O(N^2).
+     */
+    
+    for (rcell1 = resptr->rn_re; rcell1 != NULL; rcell1 = rcell1->re_nextEl)
+    {
+	rcount++;
+	if (rcount >= 10) break;
+    }
+
+    if (rcount >= 10)
+    {
+	HashTable	NodeResTable;
+	HashEntry	*he;
+
+	/* Hash the connections */
+	HashInit(&NodeResTable, HT_DEFAULTSIZE, HT_CLIENTKEYS);
+	
+	for (rcell2 = resptr->rn_re; rcell2 != NULL; rcell2 = rcell2->re_nextEl)
+	{
+	    /* One connection is always resptr;  find the other one */
+	    resptr3 = rcell2->re_thisEl->rr_connection1;
+	    if (resptr3 == resptr) resptr3 = rcell2->re_thisEl->rr_connection2;
+	    
+	    he = HashFind(&NodeResTable, (char *)resptr3);
+	    if ((rcell1 = (resElement*)HashGetValue(he)))
+	    {
+		r1 = rcell1->re_thisEl;
+		r2 = rcell2->re_thisEl;
+
+		if (TTMaskHasType(ResNoMergeMask+r1->rr_tt, r2->rr_tt)) continue;
+
+		ResFixParallel(r1, r2);
+	        status = PARALLEL;
+		resptr2 = NULL;
+		if (resptr3->rn_status & RES_TRUE)
+		{
+		    resptr2 = resptr3;
+		    resptr2->rn_status &= ~RES_TRUE;
+		}
+		ResDoneWithNode(resptr);
+		if (resptr2 != NULL) ResDoneWithNode(resptr2);
+		break;
+	    }
+	    else
+		HashSetValue(he, (char *)rcell2);
+	}
+	HashKill(&NodeResTable);
+	return status;
+    }
+
+    /* This does the same thing as above, but for a small number of resistors
+     * per node, it avoids the overhead of creating and destroying hash tables.
+     */
 
     for (rcell1 = resptr->rn_re; rcell1->re_nextEl != NULL;
 		    rcell1 = rcell1->re_nextEl)
@@ -447,6 +503,7 @@ ResParallelCheck(resptr)
 	}
 	if (status == PARALLEL) break;
     }
+
     return status;
 }
 
@@ -473,6 +530,179 @@ ResTriangleCheck(resptr)
     float	r1, r2, r3, denom;
     resNode	*n1, *n2, *n3;
     resElement	*rcell1, *rcell2, *rcell3, *element;
+    int		rcount = 0;
+
+    /* When the size of the linked list of resistors is long, it is faster to
+     * hash the neighboring connections and then find the first entry in the
+     * neighbor's node list that is another neighbor.
+     */
+    for (rcell1 = resptr->rn_re; rcell1 != NULL; rcell1 = rcell1->re_nextEl)
+    {
+	rcount++;
+	if (rcount >= 10) break;
+    }
+
+    if (rcount >= 10)
+    {
+	HashTable	NodeResTable;
+	HashEntry	*he, *he2;
+	HashSearch	hs;
+
+	/* Hash the neighboring connections */
+	HashInit(&NodeResTable, HT_DEFAULTSIZE, HT_CLIENTKEYS);
+
+	for (rcell2 = resptr->rn_re; rcell2 != NULL; rcell2 = rcell2->re_nextEl)
+	{
+	    rr2 = rcell2->re_thisEl;
+
+	    /* One connection is always resptr;  find the other one */
+	    n2 = rr2->rr_connection1;
+	    if (n2 == resptr) n2 = rr2->rr_connection2;
+
+	    he = HashFind(&NodeResTable, (char *)n2);
+	    if (!(rcell1 = (resElement *)HashGetValue(he)))
+		HashSetValue(he, (char *)rcell2);
+	}
+
+	HashStartSearch(&hs);
+	while ((he = HashNext(&NodeResTable, &hs)))
+	{
+	    /* Get each node that neighbors resptr */
+	    n1 = (resNode *)he->h_key.h_ptr;
+	    rcell1 = (resElement *)HashGetValue(he);
+	    rr1 = rcell1->re_thisEl;
+
+	    /* Check the list of resistors of neighbor n1 for any resistor whose
+	     * other end is also a neighbor of resptr.
+	     */
+	    for (rcell3 = n1->rn_re; rcell3 != NULL; rcell3 = rcell3->re_nextEl)
+	    {
+		rr3 = rcell3->re_thisEl;
+
+		/* Resistor can't be merged */
+		if (TTMaskHasType(ResNoMergeMask + rr1->rr_tt, rr3->rr_tt))
+		    continue;
+
+		/* One connection is always n1;  find the other one */
+		n2 = rr3->rr_connection1;
+		if (n2 == n1) n2 = rr3->rr_connection2;
+
+		he2 = HashLookOnly(&NodeResTable, (char *)n2);
+		if (he2)
+		{
+		    /* Found a triangle */
+		    rcell2 = (resElement *)HashGetValue(he2);
+		    rr2 = rcell2->re_thisEl;
+
+		    /* . . . But it can't be merged */
+		    if (TTMaskHasType(ResNoMergeMask + rr1->rr_tt, rr2->rr_tt))
+			continue;
+		    if (TTMaskHasType(ResNoMergeMask + rr2->rr_tt, rr3->rr_tt))
+			continue;
+
+		    status = TRIANGLE;
+		    if ((denom = rr1->rr_value + rr2->rr_value + rr3->rr_value) != 0.0)
+		    {
+			denom = 1.0  /denom;
+			/* calculate new values for resistors */
+			r1 = (((float)rr1->rr_value) * ((float)rr2->rr_value)) * denom;
+			r2 = (((float)rr2->rr_value) * ((float)rr3->rr_value)) * denom;
+			r3 = (((float)rr1->rr_value) * ((float)rr3->rr_value)) * denom;
+
+			rr1->rr_value = r1 + 0.5;
+			rr2->rr_value = r2 + 0.5;
+			rr3->rr_value = r3 + 0.5;
+			ASSERT(rr1->rr_value >= 0, "Triangle");
+			ASSERT(rr2->rr_value >= 0, "Triangle");
+			ASSERT(rr3->rr_value >= 0, "Triangle");
+		    }
+		    else
+		    {
+			rr1->rr_value = 0;
+			rr2->rr_value = 0;
+			rr3->rr_value = 0;
+		    }
+		    n3 = (resNode *)mallocMagic((unsigned)(sizeof(resNode)));
+
+		    /* Where should the new node be put?  It    */
+		    /* is arbitrarily assigned to the location	*/
+		    /* occupied by the first node.		*/
+
+		    InitializeResNode(n3, resptr->rn_loc.p_x, resptr->rn_loc.p_y, TRIANGLE);
+		    n3->rn_status = RES_FINISHED | RES_TRUE | RES_MARKED;
+
+		    n3->rn_less = NULL;
+		    n3->rn_more = ResNodeList;
+		    ResNodeList->rn_less = n3;
+		    ResNodeList = n3;
+		    if (resptr == rr1->rr_connection1)
+		    {
+			ResDeleteResPointer(rr1->rr_connection2, rr1);
+			rr1->rr_connection2 = n3;
+		    }
+		    else
+		    {
+			ResDeleteResPointer(rr1->rr_connection1, rr1);
+			rr1->rr_connection1 = n3;
+		    }
+		    if (n2 == rr2->rr_connection1)
+		    {
+			ResDeleteResPointer(rr2->rr_connection2, rr2);
+			rr2->rr_connection2 = n3;
+		    }
+		    else
+		    {
+			ResDeleteResPointer(rr2->rr_connection1, rr2);
+			rr2->rr_connection1 = n3;
+		    }
+		    if (n1 == rr3->rr_connection1)
+		    {
+			ResDeleteResPointer(rr3->rr_connection2, rr3);
+			rr3->rr_connection2 = n3;
+		    }
+		    else
+		    {
+			ResDeleteResPointer(rr3->rr_connection1, rr3);
+			rr3->rr_connection1 = n3;
+		    }
+		    element = (resElement *)mallocMagic((unsigned)(sizeof(resElement)));
+		    element->re_nextEl = NULL;
+		    element->re_thisEl = rr1;
+		    n3->rn_re = element;
+		    element = (resElement *)mallocMagic((unsigned)(sizeof(resElement)));
+		    element->re_nextEl = n3->rn_re;
+		    element->re_thisEl = rr2;
+		    n3->rn_re = element;
+		    element = (resElement *)mallocMagic((unsigned)(sizeof(resElement)));
+		    element->re_nextEl = n3->rn_re;
+		    element->re_thisEl = rr3;
+		    n3->rn_re = element;
+		    if ((n1->rn_status & RES_TRUE) == RES_TRUE)
+			n1->rn_status &= ~RES_TRUE;
+		    else
+			n1 = NULL;
+
+		    if ((n2->rn_status & RES_TRUE) == RES_TRUE)
+			n2->rn_status &= ~RES_TRUE;
+		    else
+		 	n2 = NULL;
+
+		    ResDoneWithNode(resptr);
+		    if (n1 != NULL) ResDoneWithNode(n1);
+		    if (n2 != NULL) ResDoneWithNode(n2);
+		    break;
+		}
+	    }
+	    if (status == TRIANGLE) break;
+	}
+	
+	HashKill(&NodeResTable);
+	return status;
+    }
+
+    /* This does the same thing as above, but for a small number of resistors
+     * per node, avoiding the overhead of creating and destroying hash tables.
+     */
 
     for (rcell1 = resptr->rn_re; rcell1->re_nextEl != NULL;
 		rcell1 = rcell1->re_nextEl)
@@ -609,9 +839,9 @@ ResTriangleCheck(resptr)
  *
  * ResMergeNodes--
  *
- * results: none
+ * Results: none
  *
- * side effects: appends all the cElement, jElement, tElement and
+ * Side Effects: appends all the cElement, jElement, tElement and
  *       resElement structures from node 2 onto node 1.  Node 2 is
  *	 then eliminated.
  *
@@ -780,7 +1010,7 @@ ResMergeNodes(node1, node2, pendingList, doneList)
  * ResDeleteResPointer-- Deletes the pointer from a node to a resistor.
  *	Used when a resistor is deleted.
  *
- * Results:none
+ * Results: none
  *
  * Side Effects: Modifies a node's resistor list.
  *
@@ -788,7 +1018,7 @@ ResMergeNodes(node1, node2, pendingList, doneList)
  */
 
 void
-ResDeleteResPointer(node,resistor)
+ResDeleteResPointer(node, resistor)
     resNode	*node;
     resResistor	*resistor;
 
@@ -829,7 +1059,7 @@ ResDeleteResPointer(node,resistor)
  *
  * ResEliminateResistor--
  *
- * Results:none
+ * Results: none
  *
  * Side Effects: Deletes a resistor. Does not delete pointers from nodes to
  *	resistor.
@@ -867,8 +1097,7 @@ ResEliminateResistor(resistor, homelist)
  *		they are no longer needed. If the 'info' option is used,
  *		the node is eradicated.
  *
- * Results:
+ * Results: none.
- *	None.
  *
  * Side Effects: frees memory
  *

resis/ResPrint.c

@@ -52,7 +52,7 @@ ResPrintExtRes(outextfile, resistors, nodename)
     char	*nodename;
 
 {
-    int	        nodenum=0;
+    int	        nodenum = 0;
     char	newname[MAXNAME];
     HashEntry  *entry;
     ResExtNode *node;
@@ -261,7 +261,7 @@ ResPrintExtNode(outextfile, nodelist, node)
     {
 	if (snode->rn_name == NULL)
 	{
-	    (void)sprintf(tmpname,"%s",nodename);
+	    (void)sprintf(tmpname, "%s", nodename);
 
 	    cp = tmpname + strlen(tmpname) - 1;
             if (*cp == '!' || *cp == '#') *cp = '\0';
@@ -342,13 +342,13 @@ ResPrintStats(resisdata, name)
     nodes = 0;
     resistors = 0;
     totalnets++;
-    for (node = ResNodeList; node != NULL; node=node->rn_more)
+    for (node = ResNodeList; node != NULL; node = node->rn_more)
 
     {
      	nodes++;
 	totalnodes++;
     }
-    for (res = ResResList; res != NULL; res=res->rr_nextResistor)
+    for (res = ResResList; res != NULL; res = res->rr_nextResistor)
     {
      	resistors++;
 	totalresistors++;

resis/ResReadExt.c

@@ -61,6 +61,7 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #define		DEV_PARAM_START		7
 
 #define		NODES_NODENAME		1
+#define		NODES_NODERES		2
 #define		NODES_NODEX		4
 #define		NODES_NODEY		5
 #define		NODES_NODETYPE		6
@@ -82,6 +83,24 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #define		PORT_URY		6
 #define		PORT_TYPE		7
 
+#define		USE_DEF_NAME		1
+#define		USE_ID_NAME		2
+#define		USE_TRANSFORM_A		3
+#define		USE_TRANSFORM_B		4
+#define		USE_TRANSFORM_C		5
+#define		USE_TRANSFORM_D		6
+#define		USE_TRANSFORM_E		7
+#define		USE_TRANSFORM_F		8
+
+/* Note that "connect" lines may repeat these six entries up to argc */
+#define		CONNECT_LLX		1
+#define		CONNECT_LLY		2
+#define		CONNECT_URX		3
+#define		CONNECT_URY		4
+#define		CONNECT_TYPE		5
+#define		CONNECT_UP_NAME		6
+#define		CONNECT_DOWN_NAME	7
+
 #define MAXDIGIT		20
 
 ResExtNode	*ResOriginalNodes;	/*Linked List of Nodes 	*/
@@ -91,11 +110,18 @@ ResFixPoint	*ResFixList;
 /*
  *-------------------------------------------------------------------------
  *
- * ResReadExt--
+ * ResReadExt --
  *
- * Results: returns 0 if ext file is correct, 1 if not.
+ * Read a .ext file for resistance extraction.  Extresist does not use
+ * the .ext file reader in extflat/EFread.c because it takes only a
+ * small amount of information from the .ext file, mainly to keep a
+ * list of nets and net names, devices and their terminals and
+ * connections, and subcell connections.  However, it does make use
+ * of the line parser and tokenizer in extflat.
  *
- * Side Effects:Reads in ExtTable and makes a hash table of nodes.
+ * Results: Returns 0 if ext file is correct, 1 if not.
+ *
+ * Side Effects:  Creates lists of nodes and devices for extresist.
  *
  *-------------------------------------------------------------------------
  */
@@ -107,8 +133,11 @@ ResReadExt(CellDef *def)
     int	result, locresult;
     int argc, n, size = 0;
     FILE *fp;
-    CellDef *dbdef;
+    CellDef *dbdef, *parent;
+    CellUse *use;
     ResExtNode *curnode;
+    HashTable parentHash;
+    HashEntry *he;
 
     /* Search for the .ext file in the same way that efReadDef() does. */
 
@@ -142,7 +171,10 @@ ResReadExt(CellDef *def)
 	}
 
 	/* We don't care about most tokens, only DEVICE, NODE, PORT,
-	 * and SUBSTRATE; and MERGE is used to locate drive points.
+	 * and SUBSTRATE; and CONNECT is used to locate sink points.
+	 * Note that MERGE is not useful here, as it may implicitly
+ 	 * merge nets in the cell, which is useful for netlisting but
+	 * not for annotating the extraction file. 
 	 */
 	switch (keyTable[n].k_key)
 	{
@@ -161,17 +193,16 @@ ResReadExt(CellDef *def)
 	    case FET:
 		locresult = ResReadFET(argc, argv);
 		break;
-	    case MERGE:
+	    case CONNECT:
-		/* To be completed */
+		locresult = ResReadConnectPoint(def, argc, argv);
-		/* ResReadDrivePoint(argc, argv); */
+		break;
+	    case PORT:
+		locresult = ResReadPort(argc, argv);
 		break;
 	    case NODE:
 	    case SUBSTRATE:
 		curnode = ResReadNode(argc, argv);
 		break;
-	    case PORT:
-		locresult = ResReadPort(argc, argv);
-		break;
 	    case ATTR:
 		locresult = ResReadAttribute(curnode, argc, argv);
 		break;
@@ -184,9 +215,293 @@ ResReadExt(CellDef *def)
 	if (locresult == 1) result = 1;
     }
     fclose(fp);
+
+    /* Find all the parent CellDefs of "def" and read the .ext file of
+     * each one to find where connections are made to this cell from
+     * parent cells.  Place drive points at each connection point.
+     */
+    HashInit(&parentHash, 32, HT_STRINGKEYS);
+
+    for (use = def->cd_parents; use; use = use->cu_nextuse)
+    {
+	if ((parent = use->cu_parent) == NULL) continue;
+	if (parent->cd_flags & CDINTERNAL) continue;
+	he = HashFind(&parentHash, parent->cd_name);
+	if ((CellDef *)HashGetValue(he) == NULL)
+	{
+	    /* Mark parent def as being visited */
+	    HashSetValue(he, (char *)parent);
+	    /* Read connection information from the parent's .ext file */
+	    ResReadParentExt(parent, def);
+	}
+    }
+    HashKill(&parentHash);
+
     return(result);
 }
 
+/*
+ *-------------------------------------------------------------------------
+ *
+ * ResReadUse --
+ *
+ *	Read a "use" statement from the .ext file of a parent CellDef of
+ *	the current def being extracted.  If the use is a use of the
+ *	current def, then save the use name and its transform in the
+ *	hash table so that later "connect" statements can be translated
+ *	into the coordinate system of the current cell def.
+ *
+ * Results:
+ *	1 if something went wrong with the parsing, 0 otherwise.
+ *
+ * Side effects:
+ *	May add to the hash table.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+int
+ResReadUse(CellDef *def,
+   int argc,
+   char *argv[],
+   HashTable *useHash)
+{
+    char *defname, *useid;
+    Transform *tinv, t;
+    HashEntry *he;
+
+    defname = argv[USE_DEF_NAME];
+
+    if (strcmp(defname, def->cd_name)) return 0;	/* Not my use */
+
+    useid = argv[USE_ID_NAME];
+
+    he = HashFind(useHash, useid);
+
+    t.t_a = atoi(argv[USE_TRANSFORM_A]);
+    t.t_b = atoi(argv[USE_TRANSFORM_B]);
+    t.t_c = atoi(argv[USE_TRANSFORM_C]);
+    t.t_d = atoi(argv[USE_TRANSFORM_D]);
+    t.t_e = atoi(argv[USE_TRANSFORM_E]);
+    t.t_f = atoi(argv[USE_TRANSFORM_F]);
+
+    tinv = (Transform *)mallocMagic(sizeof(Transform));
+    GeoInvertTrans(&t, tinv);
+
+    HashSetValue(he, (char *)tinv);
+    return 0;
+}
+
+/*
+ *-------------------------------------------------------------------------
+ *
+ * ResReadDrivePoint --
+ *
+ *	Read a "connect" statement from the .ext file of a parent CellDef
+ *	of the current def being extracted.  If the connection is made to
+ *	a use of the current def, then translate the area of the connection
+ *	into the current def, and mark the connection as a drive point of
+ *	def.
+ *
+ * Results:
+ *	1 if something went wrong with the parsing, 0 otherwise.
+ *
+ * Side effects:
+ *	May add information to the node list of def.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+int
+ResReadDrivePoint(CellDef *def,
+    int argc,
+    char *argv[],
+    HashTable *useHash)
+{
+    HashEntry	*entry;
+    ResExtNode	*node;
+    ResConnect  *newdriver;
+    int pNum;
+    TileType ttype;
+    Transform *t;
+    Rect r;
+    char *hierptr, *useid, *qptr, *downname;
+
+    /* Only handle entries that are in the use ID hash table */
+
+    useid = argv[CONNECT_DOWN_NAME];
+    if (*useid == '"') useid++;
+    hierptr = strchr(useid, '/');
+    if (hierptr != NULL) *hierptr = '\0';
+    qptr = strrchr(useid, '"');
+    if (qptr != NULL) *qptr = '\0';
+    if (hierptr != NULL)
+	downname = hierptr + 1;
+    else
+	downname = useid;	/* This is probably invalid */
+
+    entry = HashFind(useHash, useid);
+    if ((t = (Transform *)HashGetValue(entry)) == NULL) return 0;
+
+    /* Check for the given tile type */
+    ttype = DBTechNoisyNameType(argv[CONNECT_TYPE]);
+
+    if (ttype == -1)
+    {
+	TxError("Bad tile type name \"%s\" in .ext file for node %s\n",
+			argv[CONNECT_TYPE], argv[CONNECT_UP_NAME]);
+	return 1;
+    }
+
+    /* Look up the node name */
+    if (strcmp(downname, "None"))
+    {
+	entry = HashLookOnly(&ResNodeTable, downname);
+	if (entry != NULL)
+	    node = (ResExtNode *)HashGetValue(entry);
+	else
+	{
+	    TxError("Unknown node name \"%s\" in .ext file connect entry\n",
+			downname);
+	    return 1;
+	}
+
+	/* Generate new drivepoint entry */
+
+	newdriver = (ResConnect *)mallocMagic(sizeof(ResConnect));
+    
+	r.r_xbot = atoi(argv[CONNECT_LLX]);
+	r.r_ybot = atoi(argv[CONNECT_LLY]);
+	r.r_xtop = atoi(argv[CONNECT_URX]);
+	r.r_ytop = atoi(argv[CONNECT_URY]);
+
+	/* Translate the connection position from the parent to the
+	 * current cell def.
+	 */
+	GeoTransRect(t, &r, &newdriver->rc_rect);
+
+	newdriver->rc_type = ttype;
+	newdriver->rc_node = (resNode *)NULL;
+
+	newdriver->rc_next = node->drivepoints;
+	node->drivepoints = newdriver;
+	node->status |= FORCE | DRIVELOC;
+
+	if (ResOptionsFlags & ResOpt_Debug)
+	{
+	    /* Diagnostic */
+	    TxPrintf("Added driver at %d %d %d %d\n",
+			newdriver->rc_rect.r_xbot, newdriver->rc_rect.r_ybot,
+			newdriver->rc_rect.r_xtop, newdriver->rc_rect.r_ytop);
+	}
+    }
+
+    return 0;
+}
+
+/*
+ *-------------------------------------------------------------------------
+ *
+ * ResReadParentExt --
+ *
+ *	Read a .ext file for a parent cell of the cell being extracted.
+ *	Each .ext file contains a list of connection points into its
+ *	subcells.  However, no .ext file has information about how a
+ *	parent cell connects to it;  the exact connection may depend on
+ *	the layout, and may or may not coincide with marked ports.
+ *	Except for the top level cell, for which only marked ports can
+ *	be used to guess at intended points of connection, every subcell
+ *	can query its parents to find exact points of connection.
+ *
+ * Results:  Returns 0 if ext file is correct, 1 if not.
+ *
+ * Side Effects:  Creates lists of connection points for extresist.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+int
+ResReadParentExt(CellDef *parent,
+    CellDef *def)
+{
+    char *line = NULL, *argv[128];
+    int	result, locresult;
+    int argc, n, size = 0;
+    FILE *fp;
+    CellDef *dbdef;
+    ResExtNode *curnode;
+    HashTable useHash;
+    HashEntry *he;
+    HashSearch hs;
+
+    /* Search for the .ext file in the same way that efReadDef() does. */
+
+    fp = ExtFileOpen(parent, (char *)NULL, "r", (char **)NULL);
+    if (fp == NULL)
+    {
+    	TxError("Cannot open file %s%s\n", parent->cd_name, ".ext");
+	return 1;
+    }
+
+    HashInit(&useHash, 32, HT_STRINGKEYS);
+
+    /* Read in the file.  Makes use of various functions
+     * from extflat, mostly in EFread.c.
+     */
+
+    EFSaveLocs = FALSE;
+    efReadLineNum = 0;
+    result = 0;
+
+    while ((argc = efReadLine(&line, &size, fp, argv)) >= 0)
+    {
+	n = LookupStruct(argv[0], (const LookupTable *)keyTable, sizeof keyTable[0]);
+	if (n < 0)
+	{
+	    efReadError("Unrecognized token \"%s\" (ignored)\n", argv[0]);
+	    continue;
+	}
+	if (argc < keyTable[n].k_mintokens)
+	{
+	    efReadError("Not enough tokens for %s line\n", argv[0]);
+	    continue;
+	}
+
+	/* When reading a parent .ext file to find connections to
+	 * the cell being extracted by "extresist", we only care
+	 * about CONNECT lines, and USE lines so that we can
+	 * translate the connection points into the current cell def.
+	 *
+	 * Note:  This method depends on the .ext file format having
+	 * all "use" lines before "connect" lines.
+	 */
+	switch (keyTable[n].k_key)
+	{
+	    case USE:
+		locresult = ResReadUse(def, argc, argv, &useHash);
+		break;
+	    case CONNECT:
+		locresult = ResReadDrivePoint(def, argc, argv, &useHash);
+		break;
+	    default:
+		break;
+	}
+	if (locresult == 1) result = 1;
+    }
+    fclose(fp);
+
+    HashStartSearch(&hs);
+    while ((he = HashNext(&useHash, &hs)))
+    {
+	if (HashGetValue(he) != NULL)
+	{
+	    freeMagic(HashGetValue(he));	/* Free the allocated tranform */
+	    HashSetValue(he, (ClientData)NULL);
+	}
+    }
+    HashKill(&useHash);
+    return(result);
+}
 
 /*
  *-------------------------------------------------------------------------
@@ -207,20 +522,18 @@ ResReadNode(int argc, char *argv[])
 {
     HashEntry	*entry;
     ResExtNode	*node;
+    int noderesist;
 
     entry = HashFind(&ResNodeTable, argv[NODES_NODENAME]);
     node = ResExtInitNode(entry);
 
     node->location.p_x = atoi(argv[NODES_NODEX]);
     node->location.p_y = atoi(argv[NODES_NODEY]);
-
-    /* If this node was previously read as a port, then don't change the
-     * node type, which is tracking the type at the drivepoint.
-     */
-    if (!(node->status & PORTNODE))
-    {
     node->type = DBTechNameType(argv[NODES_NODETYPE]);
-    }
+    noderesist = atoi(argv[NODES_NODERES]);
+    if (noderesist < 0) noderesist = INFINITY;
+    /* Make sure node resistance is in units of milliohms */
+    node->resistance = (float)noderesist * (float)ExtCurStyle->exts_resistScale;
 
     if (node->type == -1)
     {
@@ -230,6 +543,85 @@ ResReadNode(int argc, char *argv[])
     return node;
 }
 
+/*
+ *-------------------------------------------------------------------------
+ *
+ * ResReadConnectPoint-- Reads in a "connect" statement from the .ext file
+ *	and sets node records accordingly to mark the node as a connection
+ *	point.  There is a use (instance) name associated with each connection,
+ *	which is unused for finding connection points to subcells;  we
+ *	don't care what the subcell is, only that there is a connection at
+ *	a point on a net in this cell that should be recorded and never
+ *	optimized out.
+ *
+ * Results:  0 if successful and 1 otherwise.
+ *
+ * Side Effects: see above
+ *
+ *-------------------------------------------------------------------------
+ */
+
+int
+ResReadConnectPoint(CellDef *def,
+    int argc,
+    char *argv[])
+{
+    HashEntry	*entry;
+    ResExtNode	*node;
+    ResConnect  *newsink;
+    int pNum;
+    TileType ttype;
+
+    /* Check for the given tile type */
+    ttype = DBTechNoisyNameType(argv[CONNECT_TYPE]);
+
+    if (ttype == -1)
+    {
+	TxError("Bad tile type name \"%s\" in .ext file for node %s\n",
+			argv[CONNECT_TYPE], argv[CONNECT_UP_NAME]);
+	return 1;
+    }
+
+    /* Look up the node name */
+    if (strcmp(argv[CONNECT_UP_NAME], "None"))
+    {
+	entry = HashLookOnly(&ResNodeTable, argv[CONNECT_UP_NAME]);
+	if (entry != NULL)
+	    node = (ResExtNode *)HashGetValue(entry);
+	else
+	{
+	    TxError("Unknown node name \"%s\" in .ext file connect entry\n",
+			argv[CONNECT_UP_NAME]);
+	    return 1;
+	}
+
+	/* Generate new sinkpoint entry */
+
+	newsink = (ResConnect *)mallocMagic(sizeof(ResConnect));
+    
+	newsink->rc_rect.r_xbot = atoi(argv[CONNECT_LLX]);
+	newsink->rc_rect.r_ybot = atoi(argv[CONNECT_LLY]);
+	newsink->rc_rect.r_xtop = atoi(argv[CONNECT_URX]);
+	newsink->rc_rect.r_ytop = atoi(argv[CONNECT_URY]);
+	newsink->rc_type = ttype;
+	newsink->rc_node = (resNode *)NULL;
+
+	newsink->rc_next = node->sinkpoints;
+	node->sinkpoints = newsink;
+	node->status |= FORCE | DRIVELOC;
+
+	if (ResOptionsFlags & ResOpt_Debug)
+	{
+	    /* Diagnostic */
+	    TxPrintf("Added sink at %d %d %d %d\n", newsink->rc_rect.r_xbot,
+			newsink->rc_rect.r_ybot, newsink->rc_rect.r_xtop,
+			newsink->rc_rect.r_ytop);
+	}
+    }
+
+    return 0;
+}
+
 /*
  *-------------------------------------------------------------------------
  *
@@ -240,6 +632,13 @@ ResReadNode(int argc, char *argv[])
  *
  * Side Effects: see above
  *
+ * NOTE: The use of "port" to mark drive points is restricted to top
+ * level cells, because no other information is available about how the
+ * cell connects to a parent cell.  For every cell other than the top
+ * level, the "connect" statements are used to find the actual locations
+ * where signals connect between cells through abutting or overlapping
+ * material.
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -249,22 +648,33 @@ ResReadPort(int argc,
 {
     HashEntry	*entry;
     ResExtNode	*node;
+    ResConnect  *newdriver;
 
     entry = HashFind(&ResNodeTable, argv[PORT_NAME]);
     node = ResExtInitNode(entry);
 
-    node->drivepoint.p_x = atoi(argv[PORT_LLX]);
+    /* Generate new drivepoint entry */
-    node->drivepoint.p_y = atoi(argv[PORT_LLY]);
+
-    node->status |= FORCE;
+    newdriver = (ResConnect *)mallocMagic(sizeof(ResConnect));
-    /* To do:  Check for multiple ports on a net;  each port needs its
+
-     * own drivepoint.
+    newdriver->rc_rect.r_xbot = atoi(argv[PORT_LLX]);
-     */
+    newdriver->rc_rect.r_ybot = atoi(argv[PORT_LLY]);
-    node->status |= DRIVELOC | PORTNODE;
+    newdriver->rc_rect.r_xtop = atoi(argv[PORT_URX]);
-    node->rs_bbox.r_ll = node->drivepoint;
+    newdriver->rc_rect.r_ytop = atoi(argv[PORT_URY]);
-    node->rs_bbox.r_ur.p_x = atoi(argv[PORT_URX]);
+    newdriver->rc_type = DBTechNoisyNameType(argv[PORT_TYPE]);
-    node->rs_bbox.r_ur.p_y = atoi(argv[PORT_URY]);
+    newdriver->rc_node = (resNode *)NULL;
-    node->rs_ttype = DBTechNoisyNameType(argv[PORT_TYPE]);
+
-    node->type = node->rs_ttype;
+    newdriver->rc_next = node->drivepoints;
+    node->drivepoints = newdriver;
+    node->status |= FORCE | DRIVELOC | PORTNODE;
+
+    if (ResOptionsFlags & ResOpt_Debug)
+    {
+	/* Diagnostic */
+	TxPrintf("Added port at %d %d %d %d\n",
+		newdriver->rc_rect.r_xbot, newdriver->rc_rect.r_ybot,
+		newdriver->rc_rect.r_xtop, newdriver->rc_rect.r_ytop);
+    }
 
     if (node->type == -1)
     {
@@ -273,6 +683,7 @@ ResReadPort(int argc,
     }
     return 0;
 }
+
 /*
  *-------------------------------------------------------------------------
  *
@@ -287,7 +698,7 @@ ResReadPort(int argc,
  *	None.
  *
  * Side effects:
- *	Allocates memory for a devPtr, adds to the node's firstDev linked
+ *	Allocates memory for a devPtr, adds to the node's "devices" linked
  *	list.
  * 
  *-------------------------------------------------------------------------
@@ -302,8 +713,8 @@ ResNodeAddDevice(ResExtNode *node,
 
     tptr = (devPtr *)mallocMagic((unsigned)(sizeof(devPtr)));
     tptr->thisDev = device;
-    tptr->nextDev = node->firstDev;
+    tptr->nextDev = node->devices;
-    node->firstDev = tptr;
+    node->devices = tptr;
     tptr->terminal = termtype;
 }
 
@@ -326,13 +737,11 @@ ResReadDevice(int argc,
     char *argv[])
 {
     RDev	*device;
-    int		rvalue, i, j, k;
+    int		rvalue, i, j, k, w, l;
     ExtDevice	*devptr;
     TileType	ttype;
     HashEntry	*entry;
     ResExtNode	*node;
-    ResValue	rpersquare;
-    float	wval;
 
     device = (RDev *)mallocMagic((unsigned)(sizeof(RDev)));
 
@@ -361,34 +770,20 @@ ResReadDevice(int argc,
     device->drain = (ResExtNode *)NULL;
     device->subs = (ResExtNode *)NULL;
 
-    entry = HashLookOnly(&devptr->exts_deviceResist, "linear");
+    /* Find the end of parameter arguments */
-    if (entry != NULL)
-	rpersquare = (ResValue)(spointertype)HashGetValue(entry);
-    else
-	rpersquare = (ResValue)10000.0;		/* Default to a sane value */
-
-    /* For devices, the device width is in the parameter list */
-    wval = 0.0;
     for (i = DEV_Y; i < argc; i++)
     {
 	char *eptr;
-	if ((eptr = strchr(argv[i], '=')) != NULL)
+	if ((eptr = strchr(argv[i], '=')) == NULL)
-	{
+	    if (!StrIsInt(argv[i]))
-	    if (*argv[i] == 'w')
-		sscanf(eptr + 1, "%f", &wval);
-	}
-	else if (!StrIsInt(argv[i]))
 		break;
     }
-
     if (i == argc)
     {
 	TxError("Bad device %s:  Too few arguments in .ext file\n",
 		argv[DEV_NAME]);
 	return 1;
     }
-    else
-	device->resistance = wval * rpersquare;	/* Channel resistance */
 
     /* Find and record the device terminal nodes */
     /* Note that this only records up to two terminals matching FET
@@ -406,6 +801,8 @@ ResReadDevice(int argc,
     entry = HashFind(&ResNodeTable, argv[i]);
     device->gate = (ResExtNode *)HashGetValue(entry);
     device->rs_gattr = StrDup((char **)NULL, argv[i + 2]);
+    l = atoi(argv[i + 1]);
+    w = 0;
     ResNodeAddDevice(device->gate, device, GATE);
     i += 3;
     
@@ -414,6 +811,7 @@ ResReadDevice(int argc,
 	entry = HashFind(&ResNodeTable, argv[i]);
 	device->source = (ResExtNode *)HashGetValue(entry);
 	device->rs_sattr = StrDup((char **)NULL, argv[i + 2]);
+	w = atoi(argv[i + 1]);
 	ResNodeAddDevice(device->source, device, SOURCE);
 	i += 3;
     }
@@ -423,6 +821,7 @@ ResReadDevice(int argc,
 	entry = HashFind(&ResNodeTable, argv[i]);
 	device->drain = (ResExtNode *)HashGetValue(entry);
 	device->rs_dattr = StrDup((char **)NULL, argv[i + 2]);
+	w = MAX(w, atoi(argv[i + 1]));
 	ResNodeAddDevice(device->drain, device, DRAIN);
 	i += 3;
     }
@@ -433,6 +832,7 @@ ResReadDevice(int argc,
     }
 
     device->rs_ttype = extGetDevType(devptr->exts_deviceName);
+    device->rs_wl = (l == 0) ? 0.0 : (float)w / (float)l;
 
     ResRDevList = device;
     device->layout = NULL;
@@ -456,13 +856,11 @@ ResReadFET(int argc,
     char *argv[])
 {
     RDev	*device;
-    int		rvalue, i, j, k;
+    int		rvalue, i, j, k, w, l;
     ExtDevice	*devptr;
     TileType	ttype;
     HashEntry	*entry;
     ResExtNode	*node;
-    ResValue	rpersquare;
-    float	area, perim, wval, lval;
 
     device = (RDev *)mallocMagic((unsigned)(sizeof(RDev)));
 
@@ -487,20 +885,6 @@ ResReadFET(int argc,
     device->rs_dattr = RDEV_NOATTR;
     device->rs_devptr = devptr;
 
-    entry = HashLookOnly(&devptr->exts_deviceResist, "linear");
-    if (entry != NULL)
-	rpersquare = (ResValue)(spointertype)HashGetValue(entry);
-    else
-	rpersquare = (ResValue)10000.0;		/* Default to a sane value */
-
-    /* For old-style FETs, the width is determined from area and perimeter */ 
-    area = MagAtof(argv[FET_AREA]);
-    perim = MagAtof(argv[FET_PERIM]);
-    lval = 0.5 * (perim + sqrt(perim * perim - 4 * area));
-    wval = area / lval;
-
-    device->resistance = wval * rpersquare;	/* Channel resistance */
-
     /* Find and record the FET terminal nodes */
 
     entry = HashFind(&ResNodeTable, argv[FET_GATE]);
@@ -522,6 +906,11 @@ ResReadFET(int argc,
     device->rs_sattr = StrDup((char **)NULL, argv[FET_SOURCE_ATTR]);
     device->rs_dattr = StrDup((char **)NULL, argv[FET_DRAIN_ATTR]);
 
+    l = atoi(argv[FET_GATE_ATTR - 1]);
+    w = atoi(argv[FET_SOURCE_ATTR - 1]);
+    w = MAX(w, atoi(argv[FET_DRAIN_ATTR - 1]));
+    device->rs_wl = (l == 0) ? 0.0 : (float)w / (float)l;
+
     ResRDevList = device;
     device->layout = NULL;
     return 0;
@@ -628,10 +1017,22 @@ ResReadAttribute(ResExtNode *node,
     else if (strncmp(avalue, "res:drive", 9) == 0 &&
      	      (ResOptionsFlags & ResOpt_Signal))
     {
-	node->drivepoint.p_x = atoi(argv[RES_EXT_ATTR_X]);
+	ResConnect *newdriver;
-	node->drivepoint.p_y = atoi(argv[RES_EXT_ATTR_Y]);
+
-	node->rs_ttype = DBTechNoisyNameType(argv[RES_EXT_ATTR_TYPE]);
+	/* Generate new drivepoint entry */
+
+	newdriver = (ResConnect *)mallocMagic(sizeof(ResConnect));
+    
 	node->status |= DRIVELOC;
+	newdriver->rc_rect.r_xbot = atoi(argv[RES_EXT_ATTR_X]);
+	newdriver->rc_rect.r_ybot = atoi(argv[RES_EXT_ATTR_Y]);
+	newdriver->rc_rect.r_xtop = atoi(argv[RES_EXT_ATTR_X]);
+	newdriver->rc_rect.r_ytop = atoi(argv[RES_EXT_ATTR_Y]);
+	newdriver->rc_type = DBTechNoisyNameType(argv[RES_EXT_ATTR_TYPE]);
+	newdriver->rc_node = (resNode *)NULL;
+
+	newdriver->rc_next = node->drivepoints;
+	node->drivepoints = newdriver;
     }
     return 0;
 }
@@ -668,11 +1069,11 @@ ResExtInitNode(entry)
 	node->cap_couple = 0;
 	node->resistance = 0;
 	node->type = 0;
-	node->firstDev = NULL;
+	node->devices = NULL;
 	node->name = entry->h_key.h_name;
 	node->oldname = NULL;
-	node->drivepoint.p_x = INFINITY;
+	node->drivepoints = NULL;
-	node->drivepoint.p_y = INFINITY;
+	node->sinkpoints = NULL;
 	node->location.p_x = INFINITY;
 	node->location.p_y = INFINITY;
     }

resis/ResSimple.c

@@ -12,6 +12,7 @@
 static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/resis/ResSimple.c,v 1.1.1.1 2008/02/03 20:43:50 tim Exp $";
 #endif  /* not lint */
 #include <stdio.h>
+#include <stdlib.h>	/* for qsort() */
 #include <string.h>
 #include <ctype.h>
 #include <math.h>
@@ -177,7 +178,7 @@ ResSimplifyNet(nodelist, biglist, reslist, tolerance)
 	    /* other recievers at far end? If so, reschedule other node;
 	     * deadlock will be settled from that node.
 	     */
-	    if ((MarkedReceivers+UnMarkedReceivers+NumberOfDrivers == 2) ||
+	    if ((MarkedReceivers + UnMarkedReceivers + NumberOfDrivers == 2) ||
 			(UnMarkedReceivers == 0 && MarkedReceivers > 1 &&
 			resistor2 == resistor1 && PendingReceivers == 0))
 	    {
@@ -228,7 +229,7 @@ ResSimplifyNet(nodelist, biglist, reslist, tolerance)
      * Two resistors in series? Combine them and move devices to
      * appropriate end.
      */
-    else if (numdrive+numreceive == 2 && (resistor1->rr_value < tolerance &&
+    else if (numdrive + numreceive == 2 && (resistor1->rr_value < tolerance &&
 		resistor2->rr_value < tolerance))
     {
 	if ((resistor1->rr_status & RES_MARKED) == 0 &&
@@ -361,7 +362,7 @@ ResSimplifyNet(nodelist, biglist, reslist, tolerance)
 /*
  *-------------------------------------------------------------------------
  *
- * ResMoveDevices-- move devices from one node1 to node2
+ * ResMoveDevices-- move devices from one node (node1) to anther (node2)
  *
  * Results: none
  *
@@ -386,11 +387,11 @@ ResMoveDevices(node1, node2)
 	devptr = devptr->te_nextt;
 	if (device->rd_fet_gate == node1)
    	    device->rd_fet_gate = node2;
-	else if ((device->rd_nterms >= 4) && (device->rd_fet_subs == node1))
+	else if (device->rd_fet_subs == node1)
    	    device->rd_fet_subs = node2;
-	else if (device->rd_fet_source == node1)
+	else if ((device->rd_nterms > 2) && (device->rd_fet_source == node1))
 	    device->rd_fet_source = node2;
-	else if (device->rd_fet_drain == node1)
+	else if ((device->rd_nterms > 3) && (device->rd_fet_drain == node1))
   	    device->rd_fet_drain = node2;
 	else
 	    TxError("Missing Device connection in squish routines"
@@ -401,6 +402,29 @@ ResMoveDevices(node1, node2)
     node1->rn_te = NULL;
 }
 
+/*
+ *-------------------------------------------------------------------------
+ *
+ * qrescompare ---
+ *
+ * Sort routine for qsort() to be used by ResScrunchNet().  Sorts in
+ * order of the resistor value, smallest to largest.
+ *-------------------------------------------------------------------------
+ */
+
+int
+qrescompare(const void *one, const void *two)
+{
+    int cval;
+
+    resResistor *r1 = *((resResistor **)one);
+    resResistor *r2 = *((resResistor **)two);
+
+    if (r1->rr_value < r2->rr_value) return -1;
+    else if (r1->rr_value == r2->rr_value) return 0;
+    else return 1;
+}
+
 /*
  *-------------------------------------------------------------------------
  *
@@ -424,12 +448,64 @@ ResScrunchNet(reslist, pendingList, biglist, tolerance)
     float	tolerance;
 
 {
-    resResistor *locallist = NULL, *current, *working;
+    resResistor *current, *working;
     resNode	*node1, *node2;
     resElement  *rcell1;
-    int	c1, c2;
+    int	c1, c2, count = 0;
+
+    /* Method used to sort resistors by size depends on list length */
+    for (current = *reslist; current; current = current->rr_nextResistor)
+    {
+	count++;
+	if (count >= 10) break;
+    }
 	
     /* Sort resistors by size */
+
+    if (count >= 10)
+    {
+	int i;
+	resResistor **resSortList;
+
+	/* For long lists, sort using qsort() */
+	/* NOTE:  It might be better to use the same merge sort used for
+	 * MergeSortBreaks() in ResMakeRes.c, as it does not incur the
+	 * overhead of allocating memory and populating the array.
+	 */
+	count = 0;
+	for (current = *reslist; current; current = current->rr_nextResistor)
+	    count++;
+
+	resSortList = (resResistor **)mallocMagic(count * sizeof(resResistor *));
+
+	count = 0;
+	for (current = *reslist; current; current = current->rr_nextResistor)
+	{
+	    resSortList[count] = current;
+	    count++;
+	}
+
+	/* Sort the list */
+
+	qsort(resSortList, count, sizeof(resResistor *), qrescompare);
+
+	/* Regenerate links on sorted list */
+	for (i = 0; i < count; i++)
+	{
+	    current = resSortList[i];
+	    current->rr_nextResistor = (i == count - 1) ? NULL : resSortList[i + 1];
+	    current->rr_lastResistor = (i == 0) ? NULL : resSortList[i - 1];
+	}
+	*reslist = resSortList[0];
+	
+	freeMagic(resSortList);
+    }
+    else
+    {
+	/* Original method:  Walk the linked list and re-sort by size. */
+
+	resResistor *locallist = NULL;
+
 	current = *reslist;
 	while (current != NULL)
 	{
@@ -445,8 +521,9 @@ ResScrunchNet(reslist, pendingList, biglist, tolerance)
 
 	    ResAddResistorToList(working, &locallist);
 	}
-
 	*reslist = locallist;
+    }
+
     while (*reslist != NULL && (*reslist)->rr_value < tolerance)
     {
 	current = *reslist;
@@ -501,8 +578,8 @@ ResScrunchNet(reslist, pendingList, biglist, tolerance)
 	    }
 	}
 	/*
-	 * If the current resistor isn't a deadend, add its  value and
+	 * If the current resistor isn't a dead end, add its value and
-	 * area to that of the next smallest one.  If it is a deadend,
+	 * area to that of the next smallest one.  If it is a dead end,
 	 * simply add its area to its node.
 	 */
 	if (c1 != 0 && c2 != 0)
@@ -567,7 +644,7 @@ ResAddResistorToList(resistor, locallist)
     resResistor	*resistor, **locallist;
 
 {
-    resResistor *local,*last=NULL;
+    resResistor *local, *last = NULL;
 
     for (local = *locallist; local != NULL; local = local->rr_nextResistor)
     {
@@ -630,7 +707,7 @@ ResDistributeCapacitance(nodelist, totalcap)
 
     for (workingNode = nodelist; workingNode != NULL; workingNode = workingNode->rn_more)
     {
-     	for (rptr = workingNode->rn_re; rptr != NULL; rptr=rptr->re_nextEl)
+     	for (rptr = workingNode->rn_re; rptr != NULL; rptr = rptr->re_nextEl)
 	    if (rptr->re_thisEl->rr_float.rr_area != 0.0)
 		TxError("Nonnull resistor area\n");
 
@@ -752,11 +829,11 @@ ResCalculateTDi(node, resistor, resistorvalue)
 
     ASSERT(rcd != NULL, "ResCalculateTdi");
     if (resistor == NULL)
-        rcd->rc_Tdi = rcd->rc_Cdownstream*(float)resistorvalue;
+        rcd->rc_Tdi = rcd->rc_Cdownstream * (float)resistorvalue;
     else
     {
         rcd2 = (RCDelayStuff *)resistor->rr_connection1->rn_client;
-        ASSERT(rcd2 != NULL,"ResCalculateTdi");
+        ASSERT(rcd2 != NULL, "ResCalculateTdi");
         rcd->rc_Tdi = rcd->rc_Cdownstream * (float)resistor->rr_value +
 	  		rcd2->rc_Tdi;
     }
@@ -843,25 +920,20 @@ ResPruneTree(node, minTdi, nodelist1, nodelist2, resistorlist)
  */
 
 int
-ResDoSimplify(tolerance,resisdata)
+ResDoSimplify(resisdata)
-    float	tolerance;
     ResisData 	*resisdata;
 
 {
     resNode 		*node, *slownode;
-    float 		bigres = 0;
+    float		bigres = 0.0;
-    float		millitolerance;
     float		totalcap;
-    float		rctol;
     resResistor		*res;
 
-    rctol = resisdata->tdiTolerance;
     ResSetPathRes(resisdata);
 
     for (node = ResNodeList; node != NULL; node = node->rn_more)
 	bigres = MAX(bigres, node->rn_noderes);
 
-    bigres /= OHMSTOMILLIOHMS; /* convert from milliohms to ohms */
     resisdata->rg_maxres = bigres;
 
 #ifdef PARANOID
@@ -875,7 +947,7 @@ ResDoSimplify(tolerance,resisdata)
 
     (void) ResDistributeCapacitance(ResNodeList, resisdata->rg_nodecap);
 
-    if (((tolerance > bigres) || ((ResOptionsFlags & ResOpt_Simplify) == 0)) &&
+    if (((ResOptionsFlags & ResOpt_Simplify) == 0) &&
 		((ResOptionsFlags & ResOpt_DoLumpFile) == 0))
     	return 0;
 
@@ -886,16 +958,6 @@ ResDoSimplify(tolerance,resisdata)
 
 	res = res->rr_nextResistor;
     	oldres->rr_status &= ~RES_HEAP;
-
-	/*------  NOTE:  resistors marked with RES_TDI_IGNORE are
-	 *	  part of loops but should NOT be removed.
-	if (oldres->rr_status & RES_TDI_IGNORE)
-	{
-	    ResDeleteResPointer(oldres->rr_node[0], oldres);
-	    ResDeleteResPointer(oldres->rr_node[1], oldres);
-	    ResEliminateResistor(oldres, &ResResList);
-	}
-	------*/
     }
 
     if (ResNodeAtOrigin == NULL)
@@ -903,7 +965,7 @@ ResDoSimplify(tolerance,resisdata)
 	TxError("Error:  Network simplification:  Failed to to get origin node.\n");
     	resisdata->rg_Tdi = 0;
     }
-    else if (ResOptionsFlags & ResOpt_Tdi)
+    else if (resisdata->mindelay > 0)
     {
 	if ((resisdata->rg_nodecap != -1) &&
 	 	(totalcap = ResCalculateChildCapacitance(ResNodeAtOrigin)) != -1)
@@ -911,8 +973,7 @@ ResDoSimplify(tolerance,resisdata)
 	    RCDelayStuff *rc = (RCDelayStuff *) ResNodeList->rn_client;
 
 	    resisdata->rg_nodecap = totalcap;
-	    ResCalculateTDi(ResNodeAtOrigin, (resResistor *)NULL,
+	    ResCalculateTDi(ResNodeAtOrigin, (resResistor *)NULL, 0);
-	      					resisdata->rg_bigdevres);
 	    if (rc != (RCDelayStuff *)NULL)
 		resisdata->rg_Tdi = rc->rc_Tdi;
 	    else
@@ -936,20 +997,10 @@ ResDoSimplify(tolerance,resisdata)
     else
     	resisdata->rg_Tdi = 0;
 
-    if ((rctol+1) * resisdata->rg_bigdevres * resisdata->rg_nodecap >
+    /* Simplify network */
-	    rctol * resisdata->rg_Tdi &&
-	    (ResOptionsFlags & ResOpt_Tdi) &&
-	    resisdata->rg_Tdi != -1)
-	return 0;
-
-    /* Simplify network; resistors are still in milliohms, so use
-     * millitolerance.
-     */
 
     if (ResOptionsFlags & ResOpt_Simplify)
     {
-	millitolerance = tolerance * MILLIOHMSPEROHM;
-
         /*
          * Start simplification at driver (R=0). Remove it from the done list
          * and add it to the pending list. Call ResSimplifyNet as long as
@@ -967,16 +1018,18 @@ ResDoSimplify(tolerance,resisdata)
             /* if Tdi is enabled, prune all branches whose end nodes	*/
 	    /* have time constants less than the tolerance.		*/
 
-	    if ((ResOptionsFlags & ResOpt_Tdi) &&
+	    if ((resisdata->rg_Tdi != -1) && (resisdata->mindelay > 0))
-	           resisdata->rg_Tdi != -1 &&
+	        ResPruneTree(ResNodeAtOrigin, resisdata->mindelay,
-		   rctol != 0)
-	    {
-	        ResPruneTree(ResNodeAtOrigin, (rctol + 1) *
-			resisdata->rg_bigdevres * resisdata->rg_nodecap / rctol,
 		   	&ResNodeList, &ResNodeQueue, &ResResList);
-	    }
+
 	    ResNodeAtOrigin->rn_status &= ~RES_MARKED;
-	    if (ResNodeAtOrigin->rn_less == NULL)
+	    if (ResNodeAtOrigin->rn_less == CLIENTDEFAULT)
+	    {
+		TxError("ResSimplify:  Bad resptr at node %s origin.\n",
+			ResNodeAtOrigin->rn_name);
+		return 0;
+	    }
+	    else if (ResNodeAtOrigin->rn_less == NULL)
 		ResNodeList = ResNodeAtOrigin->rn_more;
 	    else
 	        ResNodeAtOrigin->rn_less->rn_more = ResNodeAtOrigin->rn_more;
@@ -988,13 +1041,14 @@ ResDoSimplify(tolerance,resisdata)
 	    ResNodeAtOrigin->rn_less = NULL;
 	    ResNodeQueue = ResNodeAtOrigin;
 	    while (ResNodeQueue != NULL)
-	        ResSimplifyNet(&ResNodeQueue, &ResNodeList, &ResResList, millitolerance);
+	        ResSimplifyNet(&ResNodeQueue, &ResNodeList, &ResResList,
+				resisdata->minres);
 
 	    /*
-	     * Call ResScrunchNet to eliminate any remaining under tolerance
+	     * Call ResScrunchNet to eliminate any remaining under-tolerance
 	     * resistors.
 	     */
-	    ResScrunchNet(&ResResList, &ResNodeQueue, &ResNodeList, millitolerance);
+	    ResScrunchNet(&ResResList, &ResNodeQueue, &ResNodeList, resisdata->minres);
         }
     }
     return 0;

resis/ResUtils.c

@@ -231,7 +231,8 @@ ResAddPlumbing(tile, dinfo, arg)
 
    	    resDev = (resDevice *)mallocMagic((unsigned)(sizeof(resDevice)));
 	    resDev->rd_nterms = nterms;
-	    resDev->rd_terminals = (resNode **) mallocMagic(nterms * sizeof(resNode *));
+
+	    resDev->rd_terminals = (resNode **)mallocMagic(nterms * sizeof(resNode *));
 	    for (i = 0; i != nterms; i++)
 	    	resDev->rd_terminals[i] = (resNode *) NULL;
 
@@ -603,7 +604,7 @@ ResAddPlumbing(tile, dinfo, arg)
 		    }
 		}
 		/* bottom */
-		for(tp2 = LB(tp1); LEFT(tp2) < RIGHT(tp1); tp2 = TR(tp2))
+		for (tp2 = LB(tp1); LEFT(tp2) < RIGHT(tp1); tp2 = TR(tp2))
 		{
 		    resInfo *re2 = (resInfo *) TiGetClientPTR(tp2);
 		    if (TiGetTopType(tp2) == t1)
@@ -733,6 +734,7 @@ ResPreProcessDevices(TileList, DeviceList, Def)
 
 	tile = PlaneGetHint(Def->cd_planes[pNum]);
 	GOTOPOINT(tile, &(TileList->area.r_ll));
+	PlaneSetHint(Def->cd_planes[pNum], tile);
 
 	tt = TiGetType(tile);
 	tstruct = (resInfo *) TiGetClientPTR(tile);

resis/ResWrite.c

@@ -160,7 +160,7 @@ resCurrentPrintFunc(node, resistor, filename)
 void
 ResDeviceCounts()
 {
-    int i,j,k;
+    int i, j, k;
     resNode *n;
     resDevice *t;
     resResistor *r;

resis/resis.h

@@ -51,16 +51,24 @@ typedef struct resistor
 #define  rr_connection1 	rr_node[0]
 #define  rr_connection2		rr_node[1]
 
-/* Definitions for old FET-style MOSFET devices */
+/* Definitions for old FET-style MOSFET devices.  Actual devices may have
+ * any number of terminals.  "GATE" is the identifying type;  "SUBS" is
+ * the substrate/well connection (if it exists), and the other terminals
+ * make up the remaining entries.  Memory will be allocated for the
+ * substrate whether or not one is defined for the device.  If the device
+ * does not define a substrate connection, then this entry will remain
+ * NULL.
+ */
+
 #define RT_GATE		0
-#define RT_SOURCE	1
+#define RT_SUBS		1
-#define RT_DRAIN	2
+#define RT_SOURCE	2
-#define RT_SUBS		3
+#define RT_DRAIN	3
 
 #define rd_fet_gate	rd_terminals[RT_GATE]
+#define rd_fet_subs	rd_terminals[RT_SUBS]
 #define rd_fet_source	rd_terminals[RT_SOURCE]
 #define rd_fet_drain	rd_terminals[RT_DRAIN]
-#define rd_fet_subs	rd_terminals[RT_SUBS]
 
 typedef struct device
 {
@@ -79,6 +87,19 @@ typedef struct device
      Tile	       *rd_tile;	/* pointer to a tile in device	*/
 } resDevice;
 
+/*
+ * A resConnect maintains a location and tile type of a connections up
+ * (driver) or down (sink), a tile type that makes the connection, and
+ * a link to the resNode that must exist at the point of connection.
+ */
+typedef struct resconnect
+{
+    TileType		rc_type;
+    Rect		rc_rect;
+    struct resnode	*rc_node;
+    struct resconnect	*rc_next;
+} ResConnect;
+
 /*
  * A junction is formed when two tiles that connect are next to one another.
  */
@@ -100,9 +121,10 @@ typedef struct junction
 typedef struct resport
 {
      struct resport *rp_nextPort;
+     char 	    *rp_nodename;
+     ResConnect     *rp_connect;
      Rect	     rp_bbox;
      Point	     rp_loc;
-     char 	    *rp_nodename;
 } resPort;
 
 /*
@@ -252,9 +274,10 @@ typedef struct resoptions
 {
     /* Global options for extresist */
 
-    float	    tdiTolerance;
+    float	    minres;	/* Minimum network resistance to output */
-    float	    frequency;
+    float	    mindelay;	/* Minimum network delay to output */
-    float	    rthresh;
+    float	    rthresh;	/* Minimum individual resistance */
+    float	    frequency;	/* For FastHenry geometry extraction */
     struct saveList *savePlanes;
     CellDef	    *mainDef;
 
@@ -266,9 +289,8 @@ typedef struct resoptions
 
     TileType	rg_ttype;
     float	rg_maxres;
-    float	rg_nodecap;
+    float	rg_nodecap;	/* Node capacitance */
-    float	rg_Tdi;
+    float	rg_Tdi;		/* Node delay */
-    int		rg_bigdevres;
     int		rg_tilecount;
     int		rg_status;
     Point	*rg_devloc;
@@ -289,8 +311,6 @@ typedef struct rcdelaystuff
 typedef struct rdev
 {
      struct rdev	*nextDev;	/* Next device in linked list */
-     struct rdev 	*realDev;	/* Single Lumped Device for   */
-     					/* devices connected in parallel  */
      resDevice		*layout;	/* pointer to resDevice that	  */
      					/* corresponds to RDev		  */
      int		status;
@@ -298,10 +318,10 @@ typedef struct rdev
      struct resextnode	*source;
      struct resextnode	*drain;
      struct resextnode	*subs;		/* Used with subcircuit type only */
-     Point		location;	/* Location of lower left point of */
+     Point		location;	/* Location of lower left point	  */
-     					/* device.			   */
+     					/* of the device.		  */
-     float		resistance;     /* "Resistance" of device.	   */
      TileType		rs_ttype;	/* tile type for device		  */
+     float		rs_wl;		/* device W/L, if relevant	  */
      ExtDevice		*rs_devptr;	/* device extraction record	  */
      char               *rs_gattr;      /* Gate attributes, if any        */
      char               *rs_sattr;
@@ -320,17 +340,13 @@ typedef struct resextnode
     float 		cap_couple;	/* Coupling capacitance 	  */
     float		resistance;     /* Lumped resistance 		  */
     float		minsizeres;	/* Minimum size resistor allowed  */
-    Point		drivepoint;	/* optional, user specified drive */
+    ResConnect		*drivepoints;	/* Upward connections		  */
-     					/* point for network.		  */
+    ResConnect		*sinkpoints;	/* Downward connections		  */
-    TileType		rs_ttype;	/* Tiletype of drivepoint	  */
     Point		location;	/* Location of bottom of leftmost */
 					/* tile in the lowest numbered    */
 					/* plane contained in the node.	  */
-    Rect		rs_bbox;	/* Location of bottom of leftmost */
-					/* tile in the lowest numbered    */
-					/* plane contained in the node.	  */
     TileType		type;		/* Tile type of tile at location  */
-    struct devptr	*firstDev;	/* Linked list of devices	  */
+    struct devptr	*devices;	/* Linked list of devices	  */
      					/* connected to node.		  */
     char		*name;		/* Pointer to name of node stored */
      					/* in hash table.		  */
@@ -443,6 +459,7 @@ typedef struct capval
 /* Capacitance table constants */
 
 #define OHMSTOMILLIOHMS		1000
+#define MILLIOHMSTOOHMS		0.001
 
 #define UNTOUCHED	0
 #define SERIES		1
@@ -477,12 +494,12 @@ typedef struct capval
 #define		ResOpt_DoExtFile	0x0004
 #define		ResOpt_DoLumpFile	0x0008
 #define		ResOpt_RunSilent	0x0010
-#define		ResOpt_Stats		0x0020
+#define		ResOpt_Debug		0x0020
-#define		ResOpt_Tdi		0x0040
+#define		ResOpt_Stats		0x0040
 #define		ResOpt_Signal		0x0080
 #define		ResOpt_Geometry		0x0100
 #define		ResOpt_FastHenry	0x0200
-#define		ResOpt_Blackbox		0x0300
+#define		ResOpt_Blackbox		0x0400
 #define 	ResOpt_DoSubstrate	0x0800
 #define		ResOpt_Box		0x1000
 
@@ -510,7 +527,7 @@ extern ResFixPoint		*ResFixList;
 extern int			ResTileCount;
 extern ResExtNode		**ResNodeArray;
 extern CellDef			*mainDef;
-extern TileTypeBitMask		ResSDTypesBitMask;
+extern TileTypeBitMask		ResTermTypesBitMask;
 extern TileTypeBitMask		ResSubTypesBitMask;
 extern	HashTable		ResDevTable;
 extern TileTypeBitMask		ResNoMergeMask[NT];
@@ -525,6 +542,7 @@ extern int	      		ResReadResistor();
 extern int	      		ResReadAttribute();
 extern int			ResReadMerge();
 extern int			ResReadSubckt();
+extern int			ResReadParentExt();
 
 extern int			ResProcessNode();
 extern int	      		ResExtCombineParallel();
@@ -543,14 +561,18 @@ extern void			ResCheckExtNodes();
 extern void			ResSortByGate();
 extern void			ResFixDevName();
 extern void			ResWriteLumpFile();
-extern void			ResSortBreaks();
+extern int			ResSortBreaks();
 extern Plane			*extResPrepSubstrate();
+extern bool			ResEachTile();
+extern void			ResStartTile();
+
 
 /* C99 compat */
 
 extern void ExtResisForDef(CellDef *celldef, ResisData *resisdata);
 extern char *ResExtGetAttribute(char *sptr);
 extern int ResReadFET(int argc, char *argv[]);
+extern int ResReadConnectPoint(CellDef *def, int argc, char *argv[]);
 extern int ResReadPort(int argc, char *argv[]);
 extern char *ResExtGetAttribute(char *sptr);
 
@@ -567,7 +589,7 @@ extern void ResEliminateResistor();
 extern bool ResExtractNet();
 extern int  ResFracture();
 extern void ResMergeNodes();
-extern void ResNewSDDevice();
+extern void ResNewTermDevice();
 extern void ResNewSubDevice();
 extern void ResPreProcessDevices();
 extern void ResPrintDeviceList();
@@ -596,59 +618,8 @@ extern int  resWalkleft();
 extern int  resWalkright();
 extern int  resWalkup();
 
-/* Macros */
+extern void InitializeResNode();
-
+extern void ResInfoInit();
-#define InitializeResNode(node,x,y,why) \
+extern void ResNewBreak();
-{\
-	  (node)->rn_te = NULL;\
-	  (node)->rn_id=0;\
-	  (node)->rn_float.rn_area = 0.0;\
-	  (node)->rn_name = NULL;\
-	  (node)->rn_client = (ClientData)NULL;\
-	  (node)->rn_noderes = RES_INFINITY;\
-	  (node)->rn_je = NULL;\
-	  (node)->rn_status = FALSE;\
-	  (node)->rn_loc.p_x = (x);\
-	  (node)->rn_loc.p_y = (y);\
-	  (node)->rn_why = (why);\
-	  (node)->rn_ce = (cElement *) NULL;\
-	  (node)->rn_re = (resElement *) NULL;\
-}
-
-#define ResInfoInit(Info) \
-{  \
-          Info->contactList = (cElement *) NULL; \
-          Info->deviceList = (resDevice *) NULL; \
-          Info->junctionList = (ResJunction *) NULL; \
-          Info->breakList = (Breakpoint *) NULL; \
-	  Info->portList = (resPort *) NULL; \
-          Info->ri_status = FALSE; \
-	  Info->sourceEdge = 0 ; \
-}
-
-#define NEWBREAK(node,tile,px,py,crect)\
-{\
-	Breakpoint	*bp;\
-	resInfo *jX_ = (resInfo *)((tile)->ti_client); \
-	bp = (Breakpoint *) mallocMagic((unsigned)(sizeof(Breakpoint))); \
-        bp->br_next= jX_->breakList; \
-	bp->br_this = (node); \
-	bp->br_loc.p_x = px; \
-	bp->br_loc.p_y = py; \
-        bp->br_crect = (Rect *) (crect); \
-	jX_->breakList = bp; \
-}
-
-#define NEWPORT(node,tile)\
-{\
-	resPort		*rp;\
-	resInfo *pX_ = (resInfo *)((tile)->ti_client); \
-	rp = (resPort *) mallocMagic((unsigned)(sizeof(resPort))); \
-	rp->rp_nextPort = pX_->portList; \
-	rp->rp_bbox = node->rs_bbox; \
-	rp->rp_loc = node->drivepoint; \
-	rp->rp_nodename = node->name; \
-	pX_->portList = rp; \
-}
 
 #endif /* _MAGIC__RESIS__RESIS_H */

select/selCreate.c

@@ -471,12 +471,11 @@ SelectArea(scx, types, xMask, globmatch)
     if (TTMaskHasType(types, L_LABEL))
     {
 	if (globmatch != NULL)
-	    DBCellCopyGlobLabels(scx, &DBAllTypeBits, xMask, SelectUse, &labelArea,
+	    DBCellCopyGlobLabels(scx, types, xMask, SelectUse, &labelArea,
 		    globmatch);
 	else
-	    DBCellCopyAllLabels(scx, &DBAllTypeBits, xMask, SelectUse, &labelArea);
+	    DBCellCopyAllLabels(scx, types, xMask, SelectUse, &labelArea);
     }
-    else (void) DBCellCopyAllLabels(scx, types, xMask, SelectUse, &labelArea);
 
     /* Select cell uses. */
 
@@ -835,6 +834,8 @@ chunkdone:
 	if (DBIsContact(type))
 	    TTMaskSetOnlyType(&typeMask, type);
 
+	/* Allow labels to be selected as part of the chunk */
+	TTMaskSetType(&typeMask, L_LABEL);
 	SelectArea(&newscx, &typeMask, xMask, NULL);
       }
 

sim/SimDBstuff.c

@@ -93,7 +93,7 @@ SimConnectFunc(
     TileType		loctype, ctype;
     TileType		newdinfo = 0;
     int 		i, pNum;
-    static char		nodeName[256];
+    static char		nodeName[MAXPATHNAME];
     CellDef 		*def;
     TerminalPath	*tpath = cx->tc_filter->tf_tpath;
 
@@ -133,7 +133,8 @@ SimConnectFunc(
 	char c = *n;
 
 	SigDisableInterrupts();
-	strcpy(nodeName, SimGetNodeName(cx->tc_scx, tile, dinfo, tpath->tp_first));
+	strncpy(nodeName, SimGetNodeName(cx->tc_scx, tile, dinfo, tpath->tp_first),
+			MAXPATHNAME);
 	SigEnableInterrupts();
 
 	*n = c;

tcltk/libmgr.tcl

@@ -35,10 +35,10 @@ proc magic::libcallback {command} {
 
    switch $command {
       load {$winname load $celldef}
-      place {$winname getcell $celldef}
+      place {$winname getcell $celldef child 0 0}
       pick {
 	magic::tool pick
-	$winname getcell $celldef
+	$winname getcell $celldef child 0 0
 	magic::startselect $winname pick
       }
    }

tcltk/magicps.pro

@@ -1,70 +0,0 @@
-%%BeginProlog
-%
-%  PostScript prolog for output from magic plot
-%  Version: 1.0
-%  written by Tim Edwards 4/05/00  JHU Applied Physics Laboratory
-%
-%%BeginResource: procset MAGICproc 1.0 1
-% supporting definitions
-
-/MAGICsave save def
-
-/bop { 1 setlinecap 0 setlinejoin 6 setmiterlimit 0 setgray } def
-/ninit { /nChars matrix currentmatrix dup 0 get 0 eq {1} {0}
-   ifelse get abs 72 8.5 mul mul 64 div ceiling cvi def } def
-/minit { 1 1 dtransform abs dup 1 exch div /onePix exch def
-   dup /resY exch def 1 exch div /iresY exch def
-   abs dup /resX exch def 1 exch div /iresX exch def
-   /bX 64 iresX mul def /bY 64 iresY mul def
-   /pattFont StipplePattern definefont pop
-   /patterns /pattFont findfont [iresX 64 mul 0 0 iresY 64 mul 0 0] makefont def
-   /ca nChars 1 add string def
-   } def
-/StipplePattern 45 dict def
-StipplePattern begin
- /FontType 3 def
- /FontMatrix [1 0 0 1 0 0] def
- /FontBBox [0 0 1 1] def
- /Encoding 256 array def
- /PattName (P0) def
- /tmpStr 1 string def
- /NoPatt {<00>} def
- 0 1 255 { Encoding exch /NoPatt put } for
- /BuildChar {
-   1 0 0 0 1 1 setcachedevice exch begin Encoding exch get load
-   64 64 true [64 0 0 64 0 0] 5 -1 roll imagemask end } def
-end  
-/dp { StipplePattern begin dup 30 tmpStr cvrs PattName exch 1 exch
-   putinterval PattName cvn dup Encoding exch 4 -1 roll exch put exch
-   store end } def
-/sf { findfont exch scalefont setfont } bind def
-/sp { patterns setfont 2 setlinewidth } def
-/lb { gsave translate 0 0 moveto /just exch def gsave dup true charpath
-	flattenpath pathbbox grestore exch 4 -1 roll exch sub 3 1 roll sub
-	just 4 and 0 gt {just 8 and 0 eq {0.5 mul} if}{pop 0} ifelse exch
-	just 1 and 0 gt {just 2 and 0 eq {0.5 mul} if}{pop 0} ifelse exch
-	rmoveto show grestore } def
-/sl { 0 1 nChars { exch dup 3 1 roll ca 3 1 roll put } for pop } def
-/sc { setcmykcolor } bind def
-/l1 { onePix setlinewidth } def
-/l2 { onePix 2 mul setlinewidth } def
-/l3 { onePix 3 mul setlinewidth } def
-/ml { moveto lineto stroke } bind def
-/vl { moveto 0 exch rlineto stroke } bind def
-/hl { moveto 0 rlineto stroke } bind def
-/mr { rectstroke } bind def
-/mx { 4 copy rectstroke 4 -1 roll 4 -1 roll 4 copy moveto rlineto stroke
-   3 -1 roll dup neg 4 1 roll add moveto rlineto stroke } bind def
-/pl { gsave translate /d exch def 0 d neg moveto 0 d lineto stroke
-   d neg 0 moveto d 0 lineto stroke grestore } bind def
-/bx { x resX mul cvi 63 not and dup iresX mul exch
-   w resX mul sub abs 63 add cvi 64 idiv /w exch def
-   y resY mul cvi 63 not and dup iresY mul exch
-   h resY mul sub abs 63 add cvi 64 idiv /h exch def
-   /ch ca 0 w getinterval def
-   moveto h { ch gsave show grestore 0 bY rmoveto } repeat grestore } def
-/fb {/h exch def /w exch def /y exch def /x exch def gsave newpath
-   x y moveto w y lineto w h lineto x h lineto closepath clip bx } def
-/tb {1 sub 3 1 roll gsave newpath moveto {lineto} repeat closepath clip pathbbox
-   /h exch def /w exch def /y exch def /x exch def bx } def
-

tcltk/tkcon.tcl

@@ -249,6 +249,9 @@ proc ::tkcon::Init {} {
 	if {![info exists PRIV(histfile)]} {
 	    set PRIV(histfile)	[file join $env($envHome) $histfile]
 	}
+    } else {
+        set PRIV(rcfile) ""
+        set PRIV(histfile) ""
     }
 
     ## Handle command line arguments before sourcing resource file to

tcltk/tools.tcl

@@ -651,9 +651,9 @@ proc magic::startselect {window {option {}}} {
 	    select nocycle
 	 }
       }
-      set Opts(origin) [cursor]
+      set Opts(origin) [cursor internal]
       set Opts(motion) [bind ${window} <Motion>]
-      bind ${window} <Motion> [subst {$Opts(motion); set p \[cursor\]; \
+      bind ${window} <Motion> [subst {$Opts(motion); set p \[cursor internal\]; \
 	set x \[expr {\[lindex \$p 0\] - [lindex $Opts(origin) 0]}\]i; \
 	set y \[expr {\[lindex \$p 1\] - [lindex $Opts(origin) 1]}\]i; \
 	*bypass select move \${x} \${y}}]

utils/args.c

@@ -21,6 +21,7 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #endif  /* not lint */
 
 #include <stdio.h>
+#include <ctype.h>
 
 #include "utils/magic.h"
 #include "utils/utils.h"
@@ -34,12 +35,13 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
  * ArgStr --
  *
  * Process a single argument that is supposed to have a string value.
- * A string argument can appear in two ways:
+ * A string argument can appear in three ways:
  *
  *	-avalue		(a single element of argv)
  *	-a value	(two elements of argv)
+ *	"-a value"	(a single element of argv, space-separated)
  *
- * Both are recognized.
+ * All three forms are recognized.
  *
  * Results:
  *	Returns a pointer to the value, or NULL if there wasn't one.
@@ -56,15 +58,29 @@ char *
 ArgStr(
     int *pargc,
     char ***pargv,
-    const char *argType)/* For error messages: what the following string is
+    const char *argType)	/* For error messages: what the following
-			 * supposed to be interpreted as.
+				 * string is supposed to be interpreted as.
 				 */
 {
     char **argv = *pargv;
     char *result;
+    char *argptr;
 
-    if (argv[0][2])
+    argptr = argv[0];
-	return (&argv[0][2]);
+    argptr++;
+    if (*argptr == '\0')
+    {
+	TxError("Bad argument %s\n", argv[0]);
+	return NULL;
+    }
+    argptr++;
+    if (*argptr != '\0')
+    {
+	while (isspace(*argptr) && (*argptr != '\0'))
+	    argptr++;
+
+	return argptr;
+    }
 
     if ((*pargc)-- > 0)
     {
@@ -74,5 +90,5 @@ ArgStr(
     }
 
     TxError("-%c requires a following %s\n", argv[0][1], argType);
-    return (NULL);
+    return NULL;
 }

utils/main.c

@@ -988,7 +988,8 @@ mainInitFinal()
 	    }
 	}
 
-        if (getcwd(cwd, 512) == NULL || strcmp(cwd, home) || (RCFileName[0] == '/'))
+        if (getcwd(cwd, 512) == NULL || ((home != NULL) && (strcmp(cwd, home)))
+			|| (RCFileName[0] == '/'))
 	{
 	    /* Read in the .magicrc file from the current directory, if	*/
 	    /* different from HOME.					*/