Merge branch 'master' into netgen-1.5

enumeration in MatchPins() to overflow the cover() array and
cause a segmentation fault.

.gitignore

@@ -7,6 +7,7 @@ config.log
 scripts/config.log
 config.status
 scripts/config.status
+python/lvs_manager.py
 *.o
 *.so
 *~

VERSION

@@ -1 +1 @@
-1.5.210
+1.5.224

base/flatten.c

@@ -372,22 +372,16 @@ int flattenInstancesOf(char *name, int fnum, char *instance)
 
          /* update node numbers in child to unique numbers */
          oldmax = 0;
-         for (tmp = ChildStart; tmp != NULL; tmp = tmp->next) 
+         for (tmp = ChildStart; tmp != NULL; tmp = tmp->next) {
 	    if (tmp->node > oldmax) oldmax = tmp->node;
-         if (nextnode <= oldmax) nextnode = oldmax + 1;
-
-         for (tmp = ChildStart; tmp != NULL; tmp = tmp->next) 
-	    if (tmp->node <= oldmax && tmp->node > 0) {
-	       if (Debug) Printf("Update node %d --> %d\n", tmp->node, nextnode);
-	       UpdateNodeNumbers(ChildStart, tmp->node, nextnode);
-	       nextnode++;
-	    }
+	    if (tmp->node > 0) tmp->node += (nextnode - 1);
+	 }
+	 nextnode += oldmax;
 
          /* copy nodenumbers of ports from parent */
          ob2 = ParentParams;
-         for (tmp = ChildStart; tmp != NULL; tmp = tmp->next)  {
-	    if (IsPort(tmp)) {
-	       if (tmp->node > 0) {
+         for (tmp = ChildStart; tmp && IsPort(tmp); tmp = tmp->next)  {
+	     if (tmp->node > 0) {
 	          if (ob2->node == -1) {
 
 	             // Before commiting to attaching to a unconnected node, see
@@ -413,17 +407,16 @@ int flattenInstancesOf(char *name, int fnum, char *instance)
 	             Printf("Update node %d --> %d\n", tmp->node, ob2->node);
 	          }
 	          UpdateNodeNumbers(ChildStart, tmp->node, ob2->node);
-	       }
+	     }
 
-	       /* in pathological cases, the lengths of the port lists may
-                * change.  This is an error, but that is no reason to allow
-                * the code to core dump.  We avoid this by placing a 
-                * superfluous check on ob2->type
-                */
-	       if (ob2 != NULL) ob2 = ob2->next;
+	     /* in pathological cases, the lengths of the port lists may
+              * change.  This is an error, but that is no reason to allow
+              * the code to core dump.  We avoid this by placing a 
+              * superfluous check on ob2->type
+              */
+	     if (ob2 != NULL) ob2 = ob2->next;
 
-	       if (ob2 == NULL) break;
-	    }
+	     if (ob2 == NULL) break;
 	 }
 
          /* Using name == NULL to indicate that a .ext file is being 	*/
@@ -1135,12 +1128,32 @@ int UniquePins(char *name, int filenum)
    firstport = (struct objlist **)CALLOC(maxnode + 1, sizeof(struct objlist *));
 
    portcount = FIRSTPIN;
+   lob = NULL;
    for (ob = ThisCell->cell; ob != NULL; ob = ob->next) {
       if (ob->type != PORT) break;
       if (ob->node > 0) {
 	 nodecount[ob->node]++;
 	 if (nodecount[ob->node] == 2) {
-	    Printf("Duplicate pin %s in cell %s\n", ob->name, ThisCell->name);
+	    if (!(*matchfunc)(firstport[ob->node]->name, ob->name)) {
+	       Printf("Pins %s and %s are shorted in cell %s (%d)\n", ob->name,
+			firstport[ob->node]->name, ThisCell->name, ThisCell->file);
+	       /* Do not count this as a duplicate pin. */
+	       nodecount[ob->node]--;
+	       /* Move the pin adjacent to the one it is shorted to (if it	
+		* isn't already);  this will make the work of MatchPins() easier.
+		*/
+	       if (firstport[ob->node]->next != ob) {
+	          lob->next = ob->next;
+	          ob->next = firstport[ob->node]->next;
+		  firstport[ob->node]->next = ob;
+	          ob = lob;
+	       }
+	       lob = ob;
+	       continue;
+	    }
+	    else {
+	       Printf("Duplicate pin %s in cell %s\n", ob->name, ThisCell->name);
+	    }
 	 }
 	 if (nodecount[ob->node] > 1) {
 	    /* Remove this node;  prep for removal by marking with UNKNOWN */
@@ -1155,6 +1168,7 @@ int UniquePins(char *name, int filenum)
 	 }
       }
       portcount++;
+      lob = ob;
    }
 
    if (needscleanup)
@@ -1421,6 +1435,22 @@ typedef struct ecomplist {
     ECompListPtr next;
 } ECompList;
 
+/*----------------------------------------------------------------------*/
+/* Determine if a cell contains at least one device or subcircuit	*/
+/*----------------------------------------------------------------------*/
+
+int
+HasContents(struct nlist *tc)
+{
+    struct objlist *ob;
+
+    for (ob = tc->cell; ob; ob = ob->next)
+	if (ob->type == FIRSTPIN)
+	    return TRUE;
+
+    return FALSE;
+}
+
 /*------------------------------------------------------*/
 /* Survey the contents of a cell and sort into a hash	*/
 /*------------------------------------------------------*/
@@ -1518,6 +1548,7 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
     struct hashdict compdict;
     ECompare *ecomp, *ncomp;
     ECompList *list0X, *listX0;
+    int hascontents1, hascontents2;
     int match, modified = 0;
 
     if (file1 == -1)
@@ -1533,6 +1564,7 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
     if (tc1 == NULL || tc2 == NULL) return 0;
 
     InitializeHashTable(&compdict, OBJHASHSIZE);
+    listX0 = list0X = NULL;
 
     // Gather information about instances of cell "name1"
     SurveyCell(tc1, &compdict, file1, file2, 0);
@@ -1545,7 +1577,6 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
     // in the hierarchy of each instance contain devices
     // or subcircuits that have more in the compared circuit.
 
-    listX0 = list0X = NULL;
     ecomp = (ECompare *)HashFirst(&compdict);
     while (ecomp != NULL) {
 
@@ -1590,15 +1621,15 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 	    }
 	    if (match) {
 		if (ecomp->cell1 && (ecomp->num1 > 0)) {
-		    Fprintf(stdout, "Flattening instances of %s in cell %s"
+		    Fprintf(stdout, "Flattening instances of %s in cell %s (%d)"
 				" makes a better match\n", ecomp->cell1->name,
-				name1);
+				name1, file1);
 		    flattenInstancesOf(name1, file1, ecomp->cell1->name); 
 		}
 		if (ecomp->cell2 && (ecomp->num2 > 0)) {
-		    Fprintf(stdout, "Flattening instances of %s in cell %s"
+		    Fprintf(stdout, "Flattening instances of %s in cell %s (%d)"
 				" makes a better match\n", ecomp->cell2->name,
-				name2);
+				name2, file2);
 		    flattenInstancesOf(name2, file2, ecomp->cell2->name); 
 		}
 		modified++;
@@ -1650,7 +1681,7 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 	}
 
 	/* Case 2:  Cell2 class is a subcircuit, and flattening	*/
-	/* (it without regard to cell1) improves the matching.	*/
+	/* it (without regard to cell1) improves the matching.	*/
 
 	else if ((ecomp->num1 != ecomp->num2) && (ecomp->cell2 != NULL) &&
 			(ecomp->num2 != 0) && (ecomp->cell2->class == CLASS_SUBCKT)) {
@@ -1679,9 +1710,9 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 	    }
 	    if (match) {
 		if (ecomp->cell2) {
-		    Fprintf(stdout, "Flattening instances of %s in cell %s"
+		    Fprintf(stdout, "Flattening instances of %s in cell %s (%d)"
 				" makes a better match\n", ecomp->cell2->name,
-				name2);
+				name2, file2);
 		    flattenInstancesOf(name2, file2, ecomp->cell2->name); 
 		}
 		modified++;
@@ -1708,7 +1739,7 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 	}
 	
 	/* Case 3:  Cell1 class is a subcircuit, and flattening	*/
-	/* (it without regard to cell1) improves the matching.	*/
+	/* it (without regard to cell1) improves the matching.	*/
 
 	else if ((ecomp->num1 != ecomp->num2) && (ecomp->cell1 != NULL) &&
 			(ecomp->num1 != 0) && (ecomp->cell1->class == CLASS_SUBCKT)) {
@@ -1737,9 +1768,9 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 	    }
 	    if (match) {
 		if (ecomp->cell1) {
-		    Fprintf(stdout, "Flattening instances of %s in cell %s"
+		    Fprintf(stdout, "Flattening instances of %s in cell %s (%d)"
 				" makes a better match\n", ecomp->cell1->name,
-				name1);
+				name1, file1);
 		    flattenInstancesOf(name1, file1, ecomp->cell1->name); 
 		}
 		modified++;
@@ -1820,9 +1851,9 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 				    }
 				    if (found) {
 					Fprintf(stdout, "Removing zero-valued device "
-						"%s from cell %s makes a better match\n",
-						tsub1->name,
-						tc1->name);
+						"%s from cell %s (%d) makes a better "
+						"match\n",
+						tsub1->name, tc1->name, tc1->file);
 
 					/* A current source is an open, while a	    */
 					/* resistor or voltage source is a short.   */
@@ -1931,9 +1962,9 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 				    }
 				    if (found) {
 					Fprintf(stdout, "Removing zero-valued device "
-						"%s from cell %s makes a better match\n",
-						tsub2->name,
-						tc2->name);
+						"%s from cell %s (%d) makes a better "
+						"match\n",
+						tsub2->name, tc2->name, tc2->file);
 
 					/* merge node of endpoints */
 					if (ecomp->cell2->class != CLASS_ISOURCE) {
@@ -2024,8 +2055,8 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 			    if (dstr) *dstr = '[';
 			    if ((ncomp == ecomp0X) && (ecomp0X->num2 <= ecompX0->num1)) {
 				Fprintf(stdout, "Flattening instances of %s in cell %s"
-					" makes a better match\n", ecompX0->cell1->name,
-					name1);
+					"(%d) makes a better match\n",
+					ecompX0->cell1->name, name1, file1);
 				flattenInstancesOf(name1, file1, ecompX0->cell1->name); 
 			        ecompX0->num1 = 0;
 			        ecomp0X->num1 += ecompX0->num1;
@@ -2050,8 +2081,8 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 			    if (dstr) *dstr = '[';
 			    if ((ncomp == ecompX0) && (ecompX0->num1 <= ecomp0X->num2)) {
 				Fprintf(stdout, "Flattening instances of %s in cell %s"
-					" makes a better match\n", ecomp0X->cell2->name,
-					name2);
+					" (%d) makes a better match\n",
+					ecomp0X->cell2->name, name2, file2);
 				flattenInstancesOf(name2, file2, ecomp0X->cell2->name); 
 			        ecomp0X->num2 = 0;
 			        ecompX0->num2 += ecomp0X->num2;
@@ -2065,6 +2096,7 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 	}
     }
 
+done:
     // Free the hash table and its contents.
 
     ecomp = (ECompare *)HashFirst(&compdict);

base/flatten.h

@@ -3,5 +3,6 @@
 
 extern int UniquePins(char *name, int filenum);
 extern void flattenCell(char *name, int file);
+extern int HasContents(struct nlist *);
 
 #endif /* _FLATTEN_H */

base/netcmp.c

@@ -893,9 +893,8 @@ struct FormattedList *FormatBadNodeFragment(struct Node *N)
          WITH THE SAME HASH NUMBER, are on this node */
       for (j = i+1; j < fanout; j++) {
 	if (pins[j] != NULL && 
-	    (*matchfunc) (model,
-		  pins[j]->subelement->element->object->model.class) &&
-	    pins[i]->subelement->pin_magic == pins[j]->subelement->pin_magic) {
+	    (*matchfunc)(model, pins[j]->subelement->element->object->model.class) &&
+	    	    pins[i]->subelement->pin_magic == pins[j]->subelement->pin_magic) {
 	      count++;
 	      nodelist->fanout--;
 	      pins[j] = NULL;
@@ -975,16 +974,36 @@ void PrintBadNodeFragment(struct Node *N)
          WITH THE SAME HASH NUMBER, are on this node */
       for (j = i+1; j < fanout; j++) {
 	if (pins[j] != NULL && 
-	    (*matchfunc)(model,
-		  pins[j]->subelement->element->object->model.class) &&
-	    pins[i]->subelement->pin_magic == pins[j]->subelement->pin_magic) {
-	      count++;
-	      pins[j] = NULL;
-	    }
+	    (*matchfunc)(model, pins[j]->subelement->element->object->model.class) &&
+	    	    pins[i]->subelement->pin_magic == pins[j]->subelement->pin_magic) {
+	   count++;
+	   /* pins[j] = NULL; */ /* Done in diagnostic output, below */
+	 }
       }
 
-      if (i != 0) Fprintf(stdout, ";");
+      if (i != 0) {
+	 /* Fprintf(stdout, ";"); */
+	 Fprintf(stdout, "\n");
+	 Ftab(stdout, 32);
+      }
       Fprintf(stdout, " %s:%s = %d", model, pinname, count);
+
+      /* Diagnostic */
+      Fprintf(stdout, "\n");
+      Ftab(stdout, 25);
+      Fprintf(stdout, ">>>  %s", pins[i]->subelement->element->object->instance);
+      for (j = i+1; j < fanout; j++) {
+	if (pins[j] != NULL && 
+	    (*matchfunc)(model, pins[j]->subelement->element->object->model.class) &&
+	    	    pins[i]->subelement->pin_magic == pins[j]->subelement->pin_magic) {
+	   /* Diagnostic */
+           Fprintf(stdout, "\n");
+           Ftab(stdout, 25);
+           Fprintf(stdout, ">>>  %s", pins[j]->subelement->element->object->instance);
+	   pins[j] = NULL;
+	}
+      }
+
       pins[i] = NULL; /* not really necessary */
     }
   Fprintf(stdout, "\n");
@@ -1367,8 +1386,8 @@ void SortUnmatchedLists(nlists1, nlists2, n1max, n2max)
 		    nlists2[n1] = temp;
 		    HashPtrInstall(nlists2[n1]->name, (void *)((long)n1 + 1), &n2hash);
 		    HashPtrInstall(nlists2[n2]->name, (void *)((long)n2 + 1), &n2hash);
-		    SortFanoutLists(nlists1[n1], nlists2[n1]);
 		}
+		SortFanoutLists(nlists1[n1], nlists2[n1]);
 	    }
 	}
 
@@ -1423,8 +1442,13 @@ void SortUnmatchedLists(nlists1, nlists2, n1max, n2max)
 		    nlists1[n2] = temp;
 		    HashPtrInstall(nlists1[n1]->name, (void *)((long)n1 + 1), &n1hash);
 		    HashPtrInstall(nlists1[n2]->name, (void *)((long)n2 + 1), &n1hash);
-		    SortFanoutLists(nlists2[n2], nlists1[n2]);
 		}
+		SortFanoutLists(nlists2[n2], nlists1[n2]);
+	    }
+	    else if ((n1max == 1) && (n2max == 1)) {
+		/* Names didn't match but there's only one entry on each side,	*/
+		/* so do a sort anyway.						*/
+		SortFanoutLists(nlists2[n2], nlists1[n2]);
 	    }
 	}
 	/* For all nets that didn't match by name, match by content */
@@ -3098,6 +3122,47 @@ struct nlist *LookupPrematchedClass(struct nlist *tc1, int file2)
    return tc2;
 }
 
+/*----------------------------------------------------------------------*/
+/* Scan the property list of a device to find the number of devices	*/
+/* implied by the total of M records.  If the device does not have a	*/
+/* property list, then return 1.  If any property list does not have an	*/
+/* "M" record, treat it as 1.						*/
+/*----------------------------------------------------------------------*/
+
+int GetNumDevices(struct objlist *ob)
+{
+    int p, found, M = 0;
+    struct objlist *obs;
+    struct valuelist *vl;
+    
+    obs = ob;
+    if (obs->type != PROPERTY)
+       for (obs = ob->next; obs && (obs->type != FIRSTPIN) &&
+		(obs->type != PROPERTY); obs = obs->next);
+
+    if ((obs == NULL) || (obs->type != PROPERTY)) return 1;
+
+    while (obs && (obs->type == PROPERTY)) {
+	found = FALSE;
+	for (p = 0; ; p++) {
+	    vl = &obs->instance.props[p];
+	    if (vl->type == PROP_ENDLIST) break;
+	    if (vl->key == NULL) continue;
+            if ((*matchfunc)(vl->key, "M")) {
+                if (vl->type == PROP_DOUBLE)
+	            M += (int)vl->value.dval;
+		else
+	            M += vl->value.ival;
+		found = TRUE;
+		break;
+	    }
+	}
+	if (found == FALSE) M++;
+	obs = obs->next;
+    }
+    return M;
+}
+
 /*----------------------------------------------------------------------*/
 /* Attempt to define FirstElementPass that will generate element	*/
 /* classes by names of pins, which will allow elements with different	*/
@@ -3119,7 +3184,7 @@ int FirstElementPass(struct Element *E, int noflat, int dolist)
   struct Element *Esrch, *Ecorr;
   struct NodeList *n;
   struct nlist *tp1, *tp2, *tp;
-  int C1, C2, i;
+  int C1, C2, M1, M2, i;
   char *ostr;
   int needflat = 0;
 #ifdef TCL_NETGEN
@@ -3160,6 +3225,8 @@ int FirstElementPass(struct Element *E, int noflat, int dolist)
 	Esrch->hashval = 1;
 	C1 = 1;
 	C2 = 0;
+	M2 = 0;
+	M1 = GetNumDevices(Esrch->object);
 	tp1 = LookupCellFile(Esrch->object->model.class, Circuit1->file);
 	tp2 = LookupClassEquivalent(Esrch->object->model.class, Circuit1->file,
 			Circuit2->file);
@@ -3171,6 +3238,7 @@ int FirstElementPass(struct Element *E, int noflat, int dolist)
 		 if (tp && tp2 && (tp->classhash == tp2->classhash)) {
 		    Ecorr->hashval = 1;
 		    C2++;
+		    M2 += GetNumDevices(Ecorr->object);
 	         }
 	      }
 	      else if (Ecorr->graph == Circuit1->file) {
@@ -3179,6 +3247,7 @@ int FirstElementPass(struct Element *E, int noflat, int dolist)
 		 if (tp && tp1 && (tp->classhash == tp1->classhash)) {
 		    Ecorr->hashval = 1;
 		    C1++;
+		    M1 += GetNumDevices(Ecorr->object);
 		 }
 	      }
 	   }
@@ -3195,10 +3264,19 @@ int FirstElementPass(struct Element *E, int noflat, int dolist)
 
 	   for (i = 0; i < left_col_end; i++) *(ostr + i) = ' ';
 	   for (i = left_col_end + 1; i < right_col_end; i++) *(ostr + i) = ' ';
-           snprintf(ostr, left_col_end, "%s (%d)", Esrch->object->model.class, C1);
-	   if (C2 > 0)
-              snprintf(ostr + left_col_end + 1, left_col_end, "%s (%d)%s", tp2->name, C2,
-			(C2 == C1) ? "" : " **Mismatch**");
+	   if (M1 == C1)
+           	snprintf(ostr, left_col_end, "%s (%d)", Esrch->object->model.class, C1);
+	   else
+           	snprintf(ostr, left_col_end, "%s (%d->%d)", Esrch->object->model.class,
+				M1, C1);
+	   if (C2 > 0) {
+	      if (M2 == C2)
+              	 snprintf(ostr + left_col_end + 1, left_col_end, "%s (%d)%s", tp2->name,
+			C2, (C2 == C1) ? "" : " **Mismatch**");
+	      else
+              	 snprintf(ostr + left_col_end + 1, left_col_end, "%s (%d->%d)%s",
+			tp2->name, M2, C2, (C2 == C1) ? "" : " **Mismatch**");
+	   }
 	   else {
               snprintf(ostr + left_col_end + 1, left_col_end, "(no matching element)");
 	   }
@@ -3237,6 +3315,7 @@ int FirstElementPass(struct Element *E, int noflat, int dolist)
      if (Esrch->graph == Circuit2->file && Esrch->hashval == 0) {
 	Esrch->hashval = 1;
 	C2 = 1;
+	M2 = GetNumDevices(Esrch->object);
 	tp2 = LookupCellFile(Esrch->object->model.class, Circuit2->file);
 	tp1 = LookupClassEquivalent(Esrch->object->model.class, Circuit2->file,
 			Circuit1->file);
@@ -3248,6 +3327,7 @@ int FirstElementPass(struct Element *E, int noflat, int dolist)
 		 if (tp->classhash == tp2->classhash) {
 		    Ecorr->hashval = 1;
 		    C2++;
+		    M2 += GetNumDevices(Ecorr->object);
 	         }
 	      }
 	   }
@@ -3263,7 +3343,12 @@ int FirstElementPass(struct Element *E, int noflat, int dolist)
 	   for (i = 0; i < left_col_end; i++) *(ostr + i) = ' ';
 	   for (i = left_col_end + 1; i < right_col_end; i++) *(ostr + i) = ' ';
            snprintf(ostr, left_col_end, "(no matching element)");
-           snprintf(ostr + left_col_end + 1, left_col_end, "%s (%d)", Esrch->object->model.class, C2);
+	   if (C2 == M2)
+              snprintf(ostr + left_col_end + 1, left_col_end, "%s (%d)",
+			Esrch->object->model.class, C2);
+	   else
+              snprintf(ostr + left_col_end + 1, left_col_end, "%s (%d->%d)",
+			Esrch->object->model.class, M2, C2);
            for (i = 0; i < right_col_end + 1; i++) if (*(ostr + i) == '\0') *(ostr + i) = ' ';
            Fprintf(stdout, ostr);
 	}
@@ -3643,12 +3728,19 @@ int CreateCompareQueue(char *name1, int file1, char *name2, int file2)
          Fprintf(stdout, "Descend level %d circuit 2\n", level);
       DescendCompareQueue(tc2, tc1, level, 0, 1);
 
+      /* NOTE:  Preemptive flattening is inefficient and can cause
+       * unnecessary flattening of cells that will never be compared.
+       * let the prematch stage take care of this.
+       */
+      /*--------------------------------------
       if (Debug == TRUE)
          Fprintf(stdout, "Flatten level %d circuit 1\n", level);
       FlattenUnmatched(tc1, name1, level, 0);
       if (Debug == TRUE)
          Fprintf(stdout, "Flatten level %d circuit 2\n", level);
       FlattenUnmatched(tc2, name2, level, 0);
+      ---------------------------------------*/
+
       level--;
    }
 
@@ -3727,8 +3819,23 @@ void RemoveCompareQueue()
    CompareQueue = NULL;
 }
 
+/*----------------------------------------------------------------------*/
+/* Output a summary of the contents of the two circuits being compared	*/
+/*----------------------------------------------------------------------*/
+
+void DescribeContents(char *name1, int file1, char *name2, int file2)
+{
+    Fprintf(stdout, "\n");  // blank line before new circuit diagnostics in log file
+    /* print preliminary statistics */
+    Printf("\nContents of circuit 1:  ");
+    DescribeInstance(name1, file1);
+    Printf("Contents of circuit 2:  ");
+    DescribeInstance(name2, file2);
+    Printf("\n");
+}
+
 /*----------------------------------*/
-/* create an initial data structure */
+/* Create an initial data structure */
 /*----------------------------------*/
 
 void CreateTwoLists(char *name1, int file1, char *name2, int file2, int dolist)
@@ -3740,14 +3847,6 @@ void CreateTwoLists(char *name1, int file1, char *name2, int file2, int dolist)
 
     ResetState();
 
-    Fprintf(stdout, "\n");  // blank line before new circuit diagnostics in log file
-    /* print preliminary statistics */
-    Printf("\nContents of circuit 1:  ");
-    DescribeInstance(name1, file1);
-    Printf("Contents of circuit 2:  ");
-    DescribeInstance(name2, file2);
-    Printf("\n");
-
     if (file1 == -1)
         tc1 = LookupCell(name1);
     else
@@ -4822,6 +4921,7 @@ int PropertyOptimize(struct objlist *ob, struct nlist *tp, int run, int series,
    // Now combine records with same properties by summing M (S).
    if (comb == FALSE) {
       for (i = 0; i < run - 1; i++) {
+	 int nr_empty = 0;
 	 for (j = i + 1; j < run; j++) {
 	    pmatch = 0;
 	    for (p = 1; p < pcount; p++) {
@@ -4945,8 +5045,14 @@ int PropertyOptimize(struct objlist *ob, struct nlist *tp, int run, int series,
 		  vlist[0][i]->value.ival += vlist[0][j]->value.ival;
 		  vlist[0][j]->value.ival = 0;
 	       }
+	       else
+		  nr_empty++;
 	    }
 	 }
+	 // If everything from i to the end of the run has been matched
+	 // and zeroed out, then nothing more can be merged.
+	 if (nr_empty == (run - (i + 1)))
+	    break;
       }
    }
 
@@ -7117,7 +7223,7 @@ struct nlist *addproxies(struct hashlist *p, void *clientdata)
 int MatchPins(struct nlist *tc1, struct nlist *tc2, int dolist)
 {
    char *cover, *ctemp;
-   char *bangptr1, *bangptr2;
+   char *bangptr1, *bangptr2, *backslashptr1, *backslashptr2;
    struct objlist *ob1, *ob2, *obn, *obp, *ob1s, *ob2s, *obt;
    struct NodeClass *NC;
    struct Node *N1, *N2;
@@ -7191,8 +7297,7 @@ int MatchPins(struct nlist *tc1, struct nlist *tc2, int dolist)
 	    if (IsPort(obn)) {
 	       i = 0;
 	       for (ob1 = tc1->cell; ob1 != NULL; ob1 = ob1->next, i++) {
-	          if ((IsPort(ob1))
-				&& (*matchfunc)(ob1->name, obn->name)) {
+	          if ((IsPort(ob1)) && (ob1->node == obn->node)) {
 		     b = 0;
                      for (N2 = NC->nodes; N2 != NULL; N2 = N2->next) {
 	                if (N2->graph != Circuit1->file) {
@@ -7217,20 +7322,41 @@ int MatchPins(struct nlist *tc1, struct nlist *tc2, int dolist)
 		     obp = N2->object;
 		     j = 0;
 	             for (ob2 = tc2->cell; ob2 != NULL; ob2 = ob2->next, j++) {
-	                if ((IsPort(ob2))
-					&& (*matchfunc)(ob2->name, obp->name)) {
+	          	if ((IsPort(ob2)) && (ob2->node == obp->node)) {
 			   if (Debug == 0) {
 			      for (m = 0; m < left_col_end; m++) *(ostr + m) = ' ';
 			      for (m = left_col_end + 1; m < right_col_end; m++) *(ostr + m) = ' ';
-			      snprintf(ostr, left_col_end, "%s", obn->name);
-			      if ((*matchfunc)(obn->name, obp->name))
-			         snprintf(ostr + left_col_end + 1, left_col_end, "%s", obp->name);
+			      snprintf(ostr, left_col_end, "%s", ob1->name);
+			      if ((*matchfunc)(ob1->name, ob2->name))
+			         snprintf(ostr + left_col_end + 1, left_col_end, "%s", ob2->name);
 			      else {
-			         snprintf(ostr + left_col_end + 1, left_col_end, "%s **Mismatch**", obp->name);
-				 /* Pins with different names are on different nets,
-				  * so this should trigger an error return code.
+				 /* Check remainder of ports to see if there is a name match on the
+				  * same net number (multiple ports tied to the same net)
 				  */
-				 result = 0;
+				 struct objlist *ob3;
+				 for (ob3 = ob2->next, ++j; ob3 != NULL; ob3 = ob3->next, j++) {
+				     if ((IsPort(ob3)) && (ob3->node == ob2->node)) {
+					if ((*matchfunc)(ob3->name, ob1->name)) {
+					   ob2 = ob3;
+			         	   snprintf(ostr + left_col_end + 1, left_col_end, "%s", ob2->name);
+					   break;
+					}
+				     }
+				     else {
+					ob3 = NULL;
+					break;	/* All pins w/the same node should be together */
+				     }
+				 }
+				 if (ob3 == NULL) {
+				    if (ob2->model.port == -1)
+				       snprintf(ostr + left_col_end + 1, left_col_end, "%s **Mismatch**", ob2->name);
+				    else
+				       snprintf(ostr + left_col_end + 1, left_col_end, "(no matching pin)");
+				    /* Pins with different names are on different nets,
+				     * so this should trigger an error return code.
+				     */
+				    result = 0;
+				 }
 			      }
 			      for (m = 0; m < right_col_end + 1; m++)
 				 if (*(ostr + m) == '\0') *(ostr + m) = ' ';
@@ -7252,7 +7378,16 @@ int MatchPins(struct nlist *tc1, struct nlist *tc2, int dolist)
 #endif
 			   ob2->model.port = i;		/* save order */
 			   *(cover + i) = (char)1;
-			   break;
+
+			   /* If there are multiple pins on the same net, cycle through them;	*/
+			   /* otherwise, move to the next entry in the partition.		*/
+			   if (ob1->next && (ob1->next->type == PORT) && (ob1->next->node == ob1->node)) {
+			      ob1 = ob1->next;
+			      ob2 = tc2->cell;	/* Restart search for matching pin */
+			      i++;
+			   }
+			   else
+			      break;
 			}
 		     }
 		     if (ob2 == NULL) {
@@ -7343,14 +7478,21 @@ int MatchPins(struct nlist *tc1, struct nlist *tc2, int dolist)
    /* This should not happen if unconnected pins are eliminated	*/
    /* so apply only to black-box (CELL_PLACEHOLDER) entries.	*/ 
    /* (Semi-hack: Allow "!" global flag) */
+   /* (Another semi-hack: Ignore the leading backslash in	*/
+   /* backslash-escaped verilog names.  Removing the backslash	*/
+   /* and ending space character is a common way to convert to	*/
+   /* legal SPICE.						*/
 
    ob1 = tc1->cell;
-   bangptr1 = strrchr(ob1->name, '!');
-   if (bangptr1 && (*(bangptr1 + 1) == '\0'))
-      *bangptr1 = '\0';
-   else bangptr1 = NULL;
   
    for (i = 0; i < numorig; i++) {
+      bangptr1 = strrchr(ob1->name, '!');
+      if (bangptr1 && (*(bangptr1 + 1) == '\0'))
+         *bangptr1 = '\0';
+      else bangptr1 = NULL;
+
+      backslashptr1 = (*(ob1->name) == '\\') ? ob1->name + 1 : ob1->name;
+
       if (*(cover + i) == (char)0) {
 	 j = 0;
          for (ob2 = tc2->cell; ob2 != NULL; ob2 = ob2->next) {
@@ -7363,8 +7505,10 @@ int MatchPins(struct nlist *tc1, struct nlist *tc2, int dolist)
 	       *bangptr2 = '\0';
 	    else bangptr2 = NULL;
 
-	    name1 = ob1->name;
-	    name2 = ob2->name;
+   	    backslashptr2 = (*(ob2->name) == '\\') ? ob2->name + 1 : ob2->name;
+
+	    name1 = backslashptr1;
+	    name2 = backslashptr2;
 
 	    /* Recognize proxy pins as matching unconnected pins */
 	    if (!strncmp(name1, "proxy", 5) && (ob2->node == -1)) name1 +=5;
@@ -7907,6 +8051,7 @@ int Compare(char *cell1, char *cell2)
 {
   int automorphisms;
 
+  DescribeContents(cell1, -1, cell2, -1);
   CreateTwoLists(cell1, -1, cell2, -1, 0);
   Permute();
   while (!Iterate()); 
@@ -7967,6 +8112,7 @@ void NETCOMP(void)
     case 'c':
       promptstring("Enter cell 1: ",name);
       promptstring("Enter cell 2: ",name2);
+      DescribeContents(name, -1, name2, -1);
       CreateTwoLists(name, -1, name2, -1, 0);
 #ifdef DEBUG_ALLOC
       PrintCoreStats();

base/netcmp.h

@@ -26,6 +26,7 @@ extern void PrintCoreStats(void);
 extern void ResetState(void);
 extern void CreateTwoLists(char *name1, int file1, char *name2, int file2,
 		int dolist);
+extern void DescribeContents(char *name1, int file1, char *name2, int file2);
 extern int Iterate(void);
 extern int VerifyMatching(void);
 extern void PrintAutomorphisms(void);
@@ -46,6 +47,7 @@ extern int  CreateCompareQueue(char *, int, char *, int);
 extern int  GetCompareQueueTop(char **, int *, char **, int *);
 extern int  PeekCompareQueueTop(char **, int *, char **, int *);
 extern void RemoveCompareQueue();
+extern int FlattenUnmatched(struct nlist *, char *, int, int);
 
 extern void PrintIllegalClasses();
 extern void PrintIllegalNodeClasses();

base/netfile.c

@@ -331,77 +331,87 @@ int GetNextLineNoNewline(char *delimiter)
 	    linetok = (char *)MALLOC(linesize + 1);
 	}
 
-	/* Check for substitutions (verilog only).  Make sure linetok is    */
-	/* large enough to hold the entire line after substitutions.	    */
-
-	if (definitions != NULL) {
-	    char *s, *w, e;
-	    struct property *kl;
-	    int len, dlen, vlen, addin = 0;
-	    unsigned char found = FALSE;
-
-	    for (s = line; *s != '\0'; s++) {
-		if (*s == '`') {
-		    w = s + 1;
-		    while (isalnum(*w) || (*w == '_') || (*w == '$')) w++;
-		    e = *w;
-		    *w = '\0';
-		    kl = (struct property *)HashLookup(s + 1, definitions);
-		    if (kl != NULL) {
-			dlen = strlen(s);
-			if (kl->type == PROP_STRING) {
-			    vlen = strlen(kl->pdefault.string);
-			}
-			else vlen = 12;  /* Leave room for numeric conversion */
-			addin += vlen - dlen + 1;
-			found = TRUE;
-		    }
-		    *w = e;
-		}
-	    }
-	    if (found) {
-		len = strlen(line);
-		if (len + addin > linesize) {
-		    while (len + addin > linesize) linesize += 500;
-		    FREE(linetok);
-		    linetok = (char *)MALLOC(linesize);
-		}
-	    }
-	}
-
-	/* Make definition substitutions (verilog only) */
-
-	if (definitions != NULL) {
+	if (definitions == NULL)
+	    strcpy(linetok, line);
+	else {
 	    char *s, *t, *w, e;
 	    struct property *kl;
+	    int len, dlen, vlen, addin = 0;
+	    int oldlinesize = linesize;
+	    unsigned char found = TRUE;
 
-	    t = linetok;
-	    for (s = line; *s != '\0'; s++) {
-		if (*s == '`') {
-		    w = s + 1;
-		    while (isalnum(*w) || (*w == '_') || (*w == '$')) w++;
-		    e = *w;
-		    *w = '\0';
-		    kl = (struct property *)HashLookup(s + 1, definitions);
-		    if (kl != NULL) {
-			if (kl->type == PROP_STRING)
-			    strcpy(t, kl->pdefault.string);
-			else if (kl->type == PROP_INTEGER)
-			    sprintf(t, "%d", kl->pdefault.ival);
-			else if (kl->type == PROP_DOUBLE)
-			    sprintf(t, "%g", kl->pdefault.dval);
-			t += strlen(t);
-			s = w - 1;
+	    /* Check for substitutions (verilog only).  Make sure linetok is	*/
+	    /* large enough to hold the entire line after substitutions.	*/
+
+	    while (found) {	/* Do this recursively, for nested definitions */
+	       found = FALSE;
+
+	       for (s = line; *s != '\0'; s++) {
+		    if (*s == '`') {
+		        w = s + 1;
+		        while (isalnum(*w) || (*w == '_') || (*w == '$')) w++;
+		        e = *w;
+		        *w = '\0';
+		        kl = (struct property *)HashLookup(s + 1, definitions);
+		        if (kl != NULL) {
+			    dlen = strlen(s);
+			    if (kl->type == PROP_STRING) {
+			        vlen = strlen(kl->pdefault.string);
+			    }
+			    else vlen = 12;  /* Leave room for numeric conversion */
+			    addin += vlen - dlen + 1;
+			    found = TRUE;
+		        }
+		        *w = e;
+		    }
+	        }
+	        if (found) {
+		    len = strlen(line);
+		    if (len + addin > linesize) {
+		        while (len + addin > linesize) linesize += 500;
+		        FREE(linetok);
+		        linetok = (char *)MALLOC(linesize);
+		    }
+	        }
+
+		/* Make definition substitutions (verilog only) */
+
+	        t = linetok;
+	        for (s = line; *s != '\0'; s++) {
+		    if (*s == '`') {
+		        w = s + 1;
+		        while (isalnum(*w) || (*w == '_') || (*w == '$')) w++;
+		        e = *w;
+		        *w = '\0';
+		        kl = (struct property *)HashLookup(s + 1, definitions);
+		        if (kl != NULL) {
+			    if (kl->type == PROP_STRING)
+			        strcpy(t, kl->pdefault.string);
+			    else if (kl->type == PROP_INTEGER)
+			        sprintf(t, "%d", kl->pdefault.ival);
+			    else if (kl->type == PROP_DOUBLE)
+			        sprintf(t, "%g", kl->pdefault.dval);
+			    t += strlen(t);
+			    s = w - 1;
+		        }
+		        else *t++ = *s;
+		        *w = e;
 		    }
 		    else *t++ = *s;
-		    *w = e;
+	        }
+	        *t = '\0';
+
+		/* Copy substituted linetok back to line and repeat until */
+		/* there are no more substitutions to be made.		  */
+
+		if (oldlinesize != linesize) {
+		    FREE(line);
+	    	    line = (char *)MALLOC(linesize + 501);
+		    oldlinesize = linesize;
 		}
-		else *t++ = *s;
+		strcpy(line, linetok);
 	    }
-	    *t = '\0';
 	}
-	else
-	    strcpy(linetok, line);
 
 	TrimQuoted(linetok);
 	linenum++;

base/netgen.c

@@ -3337,16 +3337,13 @@ int CombineParallel(char *model, int file)
 	    /* "sob" to it.  If "ob" does not have properties, then	*/
 	    /* create a property record and set property "M" to 1.	*/
 
-	    /* Find last non-property record of sob ( = pob) */
-	    /* Find first property record of sob ( = spropfirst) */
-	    /* Find last property record of sob ( = sproplast)	*/
+	    /* Find last non-property record of sob ( = pob) 		*/
+	    /* Find first property record of sob ( = spropfirst) 	*/
 
-	    spropfirst = sproplast = NULL;
+	    spropfirst = NULL;
 	    for (ob2 = sob; ob2->type > FIRSTPIN || ob2 == sob; ob2 = ob2->next)
 	       pob = ob2;
 	    if (ob2->type == PROPERTY) spropfirst = ob2;
-	    for (; ob2->type == PROPERTY; ob2 = ob2->next)
-	       sproplast = ob2;
 	    
             if (spropfirst == NULL) {
 	       /* Create new property instance record if one doesn't exist */
@@ -3372,8 +3369,9 @@ int CombineParallel(char *model, int file)
 	       nob->next = pob->next;
 	       pob->next = nob;
 
+	       /* Handle case of contiguous entries */
 	       if (lob == pob) lob = nob;
-	       spropfirst = sproplast = nob;
+	       spropfirst = nob;
 	    }
 	    if (propfirst == NULL) {
 	       /* Create new property instance record if one doesn't exist */
@@ -3396,27 +3394,26 @@ int CombineParallel(char *model, int file)
 	       kv->type = PROP_ENDLIST;
 	       kv->value.ival = 0;
 
-	       /* Append to sob's property list */
-	       nob->next = sproplast->next;
-	       sproplast->next = nob;
-	       if (lob == sproplast) lob = nob;
+	       /* Prepend to sob's property list */
+	       nob->next = pob->next;
+	       pob->next = nob;
+	       /* Handle case of contiguous entries */
+	       if (lob == pob) lob = nob;
 	    }
-		
-	    if (propfirst != NULL) {
+	    else {
 
 	       // Series/Parallel logic:
-	       // If propfirst has _tag in properties,
-	       // then add an "open" tag at propfirst
-               add_prop_tag(propfirst, '(');
+	       // If spropfirst has _tag in properties,
+	       // then add an "open" tag at spropfirst
+               add_prop_tag(spropfirst, '(');
 
-	       // if spropfirst has _tag in properties then add an "open" tag
-	       // to spropfirst and a "close" tag to propfirst
-	       if (add_prop_tag(spropfirst, '(')) add_prop_tag(propfirst, ')');
+	       // if propfirst has _tag in properties then add an "open" tag
+	       // to propfirst and a "close" tag to spropfirst
+	       if (add_prop_tag(propfirst, '(')) add_prop_tag(spropfirst, ')');
 
-	       /* Append ob's property list to sob */
-	       proplast->next = sproplast->next;
-	       sproplast->next = propfirst;
-	       if (lob == sproplast) lob = proplast;
+	       /* Prepend ob's property list to sob */
+	       proplast->next = pob->next;
+	       pob->next = propfirst;
 	    }
 
             /* Link up around object to be removed */
@@ -3429,7 +3426,6 @@ int CombineParallel(char *model, int file)
 	       obr = nob;
 	    }
 	    dcnt++;
-
 	 }
 	 FREE((char *)pstr);
       }
@@ -3441,7 +3437,8 @@ int CombineParallel(char *model, int file)
    }
    HashKill(&devdict);
    if (dcnt > 0) {
-      Fprintf(stdout, "Class %s(%d):  Merged %d parallel devices.\n", model, file, dcnt);
+      Fprintf(stdout, "Class %s (%d):  Merged %d parallel devices.\n",
+		model, file, dcnt);
    }
    FREE(nodecount);
    return dcnt;
@@ -3739,7 +3736,8 @@ int CombineSeries(char *model, int file)
    }
    FREE(instlist);
    if (scnt > 0) {
-      Fprintf(stdout, "Class %s(%d):  Merged %d series devices.\n", model, file, scnt);
+      Fprintf(stdout, "Class %s (%d):  Merged %d series devices.\n",
+		model, file, scnt);
    }
    return scnt;
 }

base/query.c

@@ -805,11 +805,14 @@ void DescribeInstance(char *name, int file)
       /* All black-box modules and placeholders by definition have all	*/
       /* disconnected pins, so don't report those.			*/
 
-      if (!(tp->flags & CELL_PLACEHOLDER) && (tp->class != CLASS_MODULE))
-      {
-	//if (disconnectednodes == 0) Fprintf(stderr, "\n");
+      if ((!(tp->flags & CELL_PLACEHOLDER)) && (tp->class != CLASS_MODULE)) {
+	// if (disconnectednodes == 0) Fprintf(stderr, "\n");
         disconnectednodes++;
-        Fprintf(stderr, "Cell %s(%d) disconnected node: %s\n", tp->name, tp->file, ob->name);
+	/* Don't report on ports marked "port_match_error", which is just confusing. */
+	if (strcmp(ob->name, "port_match_error")) {
+           Fprintf(stderr, "Cell %s (%d) disconnected node: %s\n",
+		    tp->name, tp->file, ob->name);
+	}
       }
     }
   }

base/spice.c

@@ -940,7 +940,7 @@ skip_ends:
 	 goto baddevice;
       }
 
-      snprintf(instname, 255, "%s%s", model, inst);
+      snprintf(instname, 255, "%s:%s", model, inst);
       Cell(instname, model, collector, base, emitter);
       pobj = LinkProperties(model, kvlist);
       ReduceExpressions(pobj, NULL, CurrentCell, TRUE);
@@ -1013,7 +1013,7 @@ skip_ends:
 	 goto baddevice;
       }
 
-      snprintf(instname, 255, "%s%s", model, inst);
+      snprintf(instname, 255, "%s:%s", model, inst);
       Cell(instname, model, drain, gate, source, bulk);
       pobj = LinkProperties(model, kvlist);
       ReduceExpressions(pobj, NULL, CurrentCell, TRUE);
@@ -1104,7 +1104,7 @@ skip_ends:
 	   usemodel = 1;
 	}
 
-	snprintf(instname, 255, "%s%s", model, inst);
+	snprintf(instname, 255, "%s:%s", model, inst);
 	if (usemodel)
            Cell(instname, model, ctop, cbot);
 	else
@@ -1197,7 +1197,7 @@ skip_ends:
 	else
 	   strcpy(model, "r");		/* Use default resistor model */
 
-	snprintf(instname, 255, "%s%s", model, inst);
+	snprintf(instname, 255, "%s:%s", model, inst);
 	if (usemodel)
 	   Cell(instname, model, rtop, rbot);
 	else
@@ -1255,7 +1255,7 @@ skip_ends:
 	 Fprintf(stderr, "Device \"%s\" has wrong number of ports for a diode.\n");
 	 goto baddevice;
       }
-      snprintf(instname, 255, "%s%s", model, inst);
+      snprintf(instname, 255, "%s:%s", model, inst);
       Cell(instname, model, anode, cathode);
       pobj = LinkProperties(model, kvlist);
       ReduceExpressions(pobj, NULL, CurrentCell, TRUE);
@@ -1334,7 +1334,7 @@ skip_ends:
 	else
 	   strcpy(model, "t");		/* Use default xline model */
 
-	snprintf(instname, 255, "%s%s", model, inst);
+	snprintf(instname, 255, "%s:%s", model, inst);
 
 	if (usemodel)
 	   Cell(instname, model, node1, node2, node3, node4);
@@ -1417,7 +1417,7 @@ skip_ends:
       else
 	 strcpy(model, "l");		/* Use default inductor model */
 
-      snprintf(instname, 255, "%s%s", model, inst);
+      snprintf(instname, 255, "%s:%s", model, inst);
       if (usemodel)
 	 Cell(instname, model, end_a, end_b);
       else
@@ -1449,7 +1449,20 @@ skip_ends:
       if (LookupObject(pos, CurrentCell) == NULL) Node(pos);
       if (LookupObject(neg, CurrentCell) == NULL) Node(neg);
 
-      /* Any device properties? */
+      /* Get voltage value (if present); save as property "value" */
+
+      if (nexttok != NULL) {
+	 if (matchnocase(nexttok, "DC")) {
+	     SpiceTokNoNewline();
+	 }
+      }
+      if (nexttok != NULL) {
+	 if (StringIsValueOrExpression(nexttok)) {
+	     AddProperty(&kvlist, "value", nexttok);
+	 }
+      }
+
+      /* Any other device properties? */
       while (nexttok != NULL)
       {
 	 SpiceTokNoNewline();
@@ -1477,7 +1490,7 @@ skip_ends:
       else if (CountPorts(model, filenum) != 2) {
 	 /* Modeled device:  Make sure it has the right number of ports */
 	 Fprintf(stderr, "Device \"%s\" has wrong number of ports for a "
-			"voltage source.\n");
+			"voltage source.\n", inst);
 	 goto baddevice;
       }
       Cell(instname, model, pos, neg);
@@ -1729,7 +1742,7 @@ skip_ends:
       /* names.								  */
 
       if (strncmp(instancename, scan->name, strlen(scan->name))) {
-         snprintf(subcktname, 99, "%s%s", scan->name, instancename);
+         snprintf(subcktname, 99, "%s:%s", scan->name, instancename);
          strcpy(instancename, subcktname);
       }
       else {

base/verilog.c

@@ -60,6 +60,7 @@ the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 // See netfile.c for explanation of delimiters.  'X'
 // separates single-character delimiters from two-character delimiters.
 #define VLOG_DELIMITERS "X///**/#((**)X,;:(){}[]="
+#define VLOG_EQUATION_DELIMITERS "X///**/#((**)X,;:(){}[]=+-*/"
 #define VLOG_PIN_NAME_DELIMITERS "X///**/(**)X()"
 #define VLOG_PIN_CHECK_DELIMITERS "X///**/(**)X,;(){}"
 
@@ -71,6 +72,8 @@ the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 struct hashdict verilogparams;
 // Global storage for verilog definitions
 struct hashdict verilogdefs;
+// Record file pointer that is associated with the hash tables
+int hashfile = -1;
 
 // Global storage for wire buses
 struct hashdict buses;
@@ -127,6 +130,187 @@ char *strvchr(char *string, char c)
     return NULL;
 }
 
+/* Linked list, much like tokstack in netgen.c, but much simpler. */
+/* contents are either a value, if oper = 0, or an operator.	  */
+
+struct expr_stack {
+    int value;
+    char oper;
+    struct expr_stack *next;
+    struct expr_stack *last;
+};
+
+//-------------------------------------------------------------------------
+// Evaluate an expression for an array bound.  This is much like
+// ReduceOneExpression() in netgen.c, but only handles basic integer
+// arithmetic (+,-,*,/) and grouping by parentheses.
+//
+// Returns 1 if successful, 0 on error.
+// Evaluated result is placed in the integer pointed to by "valptr".
+//-------------------------------------------------------------------------
+
+int EvalExpr(struct expr_stack **stackptr, int *valptr)
+{
+    struct expr_stack *texp, *start, *tmp, *stack;
+    int modified, value;
+
+    stack = *stackptr;
+
+    /* Most expressions are going to be just one number, so treat
+     * that as a special case.
+     */
+    if ((stack->oper == '\0') && (stack->last == NULL)) {
+	*valptr = stack->value;
+	FREE(stack);
+	*stackptr = NULL;
+	return 1;
+    }
+
+    /* Move to the end of the stack, which is the beginning of the
+     * expression.
+     */
+    for (start = stack; start->last; start = start->last);
+
+    /* Run passes until no more modifications can be made */
+    modified = TRUE;
+
+    while (modified == TRUE) {
+	modified = FALSE;
+
+	/* Find any + or - that is used as a sign of a value */
+
+	for (texp = start; texp; texp = texp->next) {
+	    if ((texp->oper == '+') || (texp->oper == '-') || (texp->oper == '*') ||
+			(texp->oper == '/') || (texp->oper == '(')) {
+			
+		if ((texp->next != NULL) && (texp->next->next != NULL) &&
+			(texp->next->next->oper == '\0')) {
+		
+		    if (texp->next->oper == '+') {
+			/* Remove the unnecessary sign */
+			tmp = texp->next;
+			texp->next = tmp->next;
+			tmp->next->last = texp;
+			FREE(tmp);
+			modified = TRUE;
+		    }
+		    else if (texp->next->oper == '-') {
+			/* Remove the sign and negate the value */
+			tmp = texp->next;
+			texp->next->next->value = -texp->next->next->value;
+			texp->next = tmp->next;
+			tmp->next->last = texp;
+			FREE(tmp);
+			modified = TRUE;
+		    }
+		}
+	    }
+	}
+
+	/* Reduce (a * b) and (a / b) */
+
+	for (texp = start; texp; texp = texp->next) {
+	    if ((texp->last != NULL) && (texp->next != NULL) && (texp->oper != '\0')) {
+		if ((texp->last->oper == '\0') && (texp->next->oper == '\0')) {
+		    if (texp->oper == '*') {
+			/* Multiply */
+			texp->last->value *= texp->next->value;
+			/* Remove two items from the stack */
+			tmp = texp;
+			texp = texp->last;
+			texp->next = tmp->next->next;
+			if (tmp->next->next) tmp->next->next->last = texp;
+			FREE(tmp->next);
+			FREE(tmp);
+			modified = TRUE;
+		    }
+		    if (texp->oper == '/') {
+			/* Divide */
+			texp->last->value /= texp->next->value;
+			/* Remove two items from the stack */
+			tmp = texp;
+			texp = texp->last;
+			texp->next = tmp->next->next;
+			if (tmp->next->next) tmp->next->next->last = texp;
+			FREE(tmp->next);
+			FREE(tmp);
+			modified = TRUE;
+		    }
+		} 
+	    }
+	}
+
+	/* Reduce (a + b) and (a - b) */
+
+	for (texp = start; texp; texp = texp->next) {
+	    if ((texp->last != NULL) && (texp->next != NULL) && (texp->oper != '\0')) {
+		if ((texp->last->oper == '\0') && (texp->next->oper == '\0')) {
+		    if (texp->oper == '-') {
+			/* Subtract */
+			texp->last->value -= texp->next->value;
+			/* Remove two items from the stack */
+			tmp = texp;
+			texp = texp->last;
+			texp->next = tmp->next->next;
+			if (tmp->next->next) tmp->next->next->last = texp;
+			FREE(tmp->next);
+			FREE(tmp);
+			modified = TRUE;
+		    }
+		    if (texp->oper == '+') {
+			/* Add */
+			texp->last->value += texp->next->value;
+			/* Remove two items from the stack */
+			tmp = texp;
+			texp = texp->last;
+			texp->next = tmp->next->next;
+			if (tmp->next->next) tmp->next->next->last = texp;
+			FREE(tmp->next);
+			FREE(tmp);
+			modified = TRUE;
+		    }
+		} 
+	    }
+	}
+
+	/* Reduce (a) */
+
+	for (texp = start; texp; texp = texp->next) {
+	    if ((texp->last != NULL) && (texp->next != NULL) && (texp->oper == '\0')) {
+		if ((texp->last->oper == '(') && (texp->next->oper == ')')) {
+		    tmp = texp->last;
+		    texp->last->oper = '\0';
+		    texp->last->value = texp->value;
+		    texp->last->next = texp->next->next;
+		    if (texp->next->next) texp->next->next->last = texp->last;
+		    FREE(texp->next);
+		    FREE(texp);
+		    texp = tmp;
+		    modified = TRUE;
+		}
+	    }
+	}
+    }
+
+    /* If only one numerical item remains, then place it in valptr and return 1 */
+    texp = start;
+    if ((texp->oper == '\0') && (texp->next == NULL)) {
+	*valptr = texp->value;
+	FREE(texp);
+	*stackptr = NULL;
+	return 1;
+    }
+
+    /* Clean up the stack before returning error status */
+    while (texp) {
+	tmp = texp;
+	texp = texp->next;
+	FREE(tmp);
+    }
+    *stackptr = NULL;
+    return 0;
+}
+
 //-------------------------------------------------------------------------
 // Get bus indexes from the notation name[a:b].  If there is only "name"
 // then look up the name in the bus hash list and return the index bounds.
@@ -138,147 +322,123 @@ char *strvchr(char *string, char c)
 
 int GetBusTok(struct bus *wb)
 {
-    int result, start, end;
+    int result, start, end, value;
+    char oper;
     struct property *kl = NULL;
+    struct expr_stack *stack, *newexp;
 
     if (wb == NULL) return 0;
-    else {
-        wb->start = -1;
-        wb->end = -1;
-    }
+
+    wb->start = -1;
+    wb->end = -1;
+    stack = NULL;
+
+    /* Parse a value for array bounds [a : b], including possible use	*/
+    /* of parameters, definitions, and basic arithmetic.		*/
 
     if (match(nexttok, "[")) {
-	SkipTokComments(VLOG_DELIMITERS);
-
-	result = sscanf(nexttok, "%d", &start);
-	if (result != 1) {
-	    char *aptr = NULL;
-	    char addin;
-
-	    // Check for "+/-(n)" at end of a parameter name
-	    aptr = strrchr(nexttok, '+');
-	    if (aptr == NULL) aptr = strrchr(nexttok, '-');
-	    if (aptr != NULL) {
-		addin = *aptr;
-		*aptr = '\0';
-	    }
-
-	    // Is name in the parameter list?
-	    kl = (struct property *)HashLookup(nexttok, &verilogparams);
-	    if (kl == NULL) {
-		Printf("Array value %s is not a number or a parameter.\n",
-				nexttok);
-		return 1;
-	    }
-	    else {
-		if (kl->type == PROP_STRING) {
-		    result = sscanf(kl->pdefault.string, "%d", &start);
-		    if (result != 1) {
-		        Printf("Parameter %s has value %s that cannot be parsed"
-				" as an integer.\n", nexttok, kl->pdefault.string);
-			return 1;
-		    }
-		}
-		else if (kl->type == PROP_INTEGER) {
-		    start = kl->pdefault.ival;
-		}
-		else if (kl->type == PROP_DOUBLE) {
-		    start = (int)kl->pdefault.dval;
-		    if ((double)start != kl->pdefault.dval) {
-		        Printf("Parameter %s has value %g that cannot be parsed"
-				" as an integer.\n", nexttok, kl->pdefault.dval);
-			return 1;
-		    }
-		}
-		else {
-		    Printf("Parameter %s has unknown type; don't know how"
-				" to parse.\n", nexttok);
+	start = end = -1;
+	oper = '\0';
+	while (nexttok) {
+	    SkipTokComments(VLOG_EQUATION_DELIMITERS);
+    	    if (match(nexttok, "]")) {
+	    	result = 1;
+		if (stack == NULL) {
+		    Printf("Empty array found.\n");
 		    return 1;
 		}
-	    }
-	    if (aptr != NULL) {
-		int addval;
-		*aptr = addin;
-		if (sscanf(aptr + 1, "%d", &addval) != 1) {
-		    Printf("Unable to parse parameter increment '%s'\n", aptr);
+		if (EvalExpr(&stack, &end) != 1) {
+		    Printf("Bad expression found in array.\n");
 		    return 1;
 		}
-		start += (addin == '+') ? addval : -addval;
+		if (start == -1) start = end;	// Single bit
+		break;
 	    }
-	}
-	SkipTokComments(VLOG_DELIMITERS);
-	if (match(nexttok, "]")) {
-	    result = 1;
-	    end = start;	// Single bit
-	}
-	else if (!match(nexttok, ":")) {
-	    Printf("Badly formed array notation:  Expected colon, found %s\n", nexttok);
-	    return 1;
-	}
-	else {
-	    SkipTokComments(VLOG_DELIMITERS);
-
-	    result = sscanf(nexttok, "%d", &end);
-	    if (result != 1) {
-		char *aptr = NULL;
-		char addin;
-
-		// Check for "+/-(n)" at end of a parameter name
-		aptr = strrchr(nexttok, '+');
-		if (aptr == NULL) aptr = strrchr(nexttok, '-');
-		if (aptr != NULL) {
-		    addin = *aptr;
-		    *aptr = '\0';
+	    if (match(nexttok, ":")) {
+		if (stack == NULL) {
+		    Printf("Empty array start found.\n");
+		    return 1;
 		}
+		if (EvalExpr(&stack, &start) != 1) {
+		    Printf("Bad expression found in array.\n");
+		    return 1;
+		}
+		continue;
+	    }
+	    else if (match(nexttok, "+") || match(nexttok, "-")
+	    		|| match(nexttok, "*") || match(nexttok, "/")
+	    		|| match(nexttok, "(") || match(nexttok, ")")) {
+		newexp = (struct expr_stack *)MALLOC(sizeof(struct expr_stack));
+		newexp->oper = *nexttok;
+		newexp->value = 0;
+		newexp->next = NULL;
+		newexp->last = stack;
+		if (stack) stack->next = newexp;
+		stack = newexp;
+		continue;
+	    }
+	    if ((result = sscanf(nexttok, "%d", &value)) != 1) {
 
 		// Is name in the parameter list?
-	        kl = (struct property *)HashLookup(nexttok, &verilogparams);
+		kl = (struct property *)HashLookup(nexttok, &verilogparams);
 		if (kl == NULL) {
 		    Printf("Array value %s is not a number or a parameter.\n",
-					nexttok);
-		    return 1;
+				nexttok);
+		    value = 0;
+		    break;
 		}
 		else {
 		    if (kl->type == PROP_STRING) {
-			result = sscanf(kl->pdefault.string, "%d", &end);
+			result = sscanf(kl->pdefault.string, "%d", &value);
 			if (result != 1) {
 		            Printf("Parameter %s has value %s that cannot be parsed"
-					" as an integer.\n", nexttok,
-					kl->pdefault.string);
-			    return 1;
+					" as an integer.\n",
+					nexttok, kl->pdefault.string);
+		    	    value = 0;
+			    break;
 			}
 		    }
 		    else if (kl->type == PROP_INTEGER) {
-			end = kl->pdefault.ival;
+			value = kl->pdefault.ival;
 		    }
 		    else if (kl->type == PROP_DOUBLE) {
-		        end = (int)kl->pdefault.dval;
-		        if ((double)end != kl->pdefault.dval) {
-			    Printf("Cannot parse second digit from parameter "
-					"%s value %g\n", nexttok, kl->pdefault.dval);
-			    return 1;
+			value = (int)kl->pdefault.dval;
+			if ((double)value != kl->pdefault.dval) {
+		            Printf("Parameter %s has value %g that cannot be parsed"
+					" as an integer.\n",
+					nexttok, kl->pdefault.dval);
+		    	    value = 0;
+			    break;
 			}
 		    }
 		    else {
-		        Printf("Parameter %s has unknown type; don't know how"
-					" to parse.\n", nexttok);
-		        return 1;
+			Printf("Parameter %s has unknown type; don't know how"
+				" to parse.\n", nexttok);
+		    	value = 0;
+			break;
 		    }
 		}
-		if (aptr != NULL) {
-		    int addval;
-		    *aptr = addin;
-		    if (sscanf(aptr + 1, "%d", &addval) != 1) {
-			Printf("Unable to parse parameter increment '%s'\n", aptr);
-			return 1;
-		    }
-		    end += (addin == '+') ? addval : -addval;
-		}
 	    }
+
+	    newexp = (struct expr_stack *)MALLOC(sizeof(struct expr_stack));
+	    newexp->oper = '\0';
+	    newexp->value = value;
+	    newexp->next = NULL;
+	    newexp->last = stack;
+	    if (stack) stack->next = newexp;
+	    stack = newexp;
 	}
+
 	wb->start = start;
 	wb->end = end;
 
+	/* In case of error, stack may need cleaning up */
+	while (stack != NULL) {
+	    newexp = stack;
+	    stack = stack->last;
+	    FREE(newexp);
+	}
+
 	while (!match(nexttok, "]")) {
 	    SkipTokComments(VLOG_DELIMITERS);
 	    if (nexttok == NULL) {
@@ -1128,13 +1288,6 @@ skip_endmodule:
 	 kl->pdefault.ival = 1;
          kl->slop.ival = 0;
       }
-      else if (nexttok[0] == '(') {
-	 /* For now, the netgen verilog parser doesn't handle `define f(X) ... */
-	 SkipNewLine(VLOG_DELIMITERS);
-	 FREE(kl->key);
-	 FREE(kl);
-	 kl = NULL;
-      }
       else if (ConvertStringToInteger(nexttok, &ival) == 1) {
 	 /* Parameter parses as an integer */
       	 kl->type = PROP_INTEGER;
@@ -1319,6 +1472,8 @@ skip_endmodule:
 			    rhs = LookupObject(assignname, CurrentCell);
 			    *aptr = '[';
 			}
+			else
+			    strcpy(assignroot, nexttok);
 		    }
 		    else {
 			j = -1;
@@ -1514,7 +1669,7 @@ nextinst:
 
 	 // Read the pin list
          while (nexttok != NULL) {
-	    SkipTokComments(VLOG_DELIMITERS);
+	    SkipTokComments(VLOG_PIN_CHECK_DELIMITERS);
 	    if (match(nexttok, ")")) break;
 	    else if (match(nexttok, ",")) continue;
 
@@ -1778,54 +1933,6 @@ nextinst:
 	    scan->width = width;
 
 	    result = GetBus(scan->net, &wb);
-	    if (result == -1) {
-		/* CHECK:  THIS CODE SHOULD BE DELETED, IT IS NOT THE ISSUE */
-		/* Not bus notation, but check if signal was defined as a bus */
-		wb.start = wb.end = -1;
-		minnet = maxnet = -1;
-
-		/* Pins should be in index order start->end.  Other nodes */
-		/* should be in order start->end by node number.	  */
-
-		for (bobj = CurrentCell->cell; bobj; bobj = bobj->next) {
-		    if (bobj->type == PORT) {
-			if ((bptr = strvchr(bobj->name, '[')) != NULL) {
-			    *bptr = '\0';
-			    if (!strcmp(bobj->name, scan->net)) {
-				*bptr = '[';
-				if (wb.start == -1)
-				    sscanf(bptr + 1, "%d", &wb.start);
-				else
-				    sscanf(bptr + 1, "%d", &wb.end);
-			    }
-			}
-		    }
-		    else if (bobj->type == NODE) {
-			if ((bptr = strvchr(bobj->name, '[')) != NULL) {
-			    *bptr = '\0';
-			    if (!strcmp(bobj->name, scan->net)) {
-				if (sscanf(bptr + 1, "%d", &testidx) == 1) {
-				    if (minnet == -1) {
-					minnet = maxnet = bobj->node;
-					wb.start = wb.end = testidx;
-				    }
-				    else if (bobj->node < minnet) {
-					minnet = bobj->node;
-					wb.start = testidx;
-				    }
-				    else if (bobj->node > maxnet) {
-					maxnet = bobj->node;
-					wb.end = testidx;
-				    }
-				}
-			    }
-			    *bptr = '[';
-			}
-		    }
-		}
-		if (wb.start != -1) result = 0;
-	    }
-
 	    if (result == 0) {
 	       int match = 0;
 	       int wblen, arraylen;
@@ -1935,7 +2042,25 @@ nextinst:
 	       }
 	    }
 	    else if (portstart != portend) {
-	       Fprintf(stderr, "Error:  Single net %s is connected to bus port %s\n",
+	       /* If the name starts with "_noconnect_", then it was an
+		* auto-generated name that incorrectly assumed a single-bit
+		* wide signal because it did not have a module prototype.
+		* Rewrite the noconnect name as an array.  This just means
+		* that the verilog had an empty list "()" and the initial
+		* assumption was wrong.  If not all instances agree on the
+		* size, then this will eventually generate an error.
+		*/
+	       if (!strncmp(scan->net, "_noconnect_", 11) &&
+			(strchr(scan->net, '\[') == NULL) && (width > 1)) {
+		  char *savenet = scan->net;
+		  char *newnet = MALLOC(strlen(scan->net) + 12);
+		  sprintf(newnet, "%s[%d:0]", scan->net, scan->width - 1);
+		  FREE(savenet);
+		  scan->net = newnet;
+		  continue;	/* Re-process this entry */
+	       }
+	       else
+	          Fprintf(stderr, "Error:  Single net %s is connected to bus port %s\n",
 			scan->net, scan->name);
 	    }
 	 }
@@ -2117,7 +2242,7 @@ nextinst:
 					sobj = sobj->next) {
 			      if (sobj->type == FIRSTPIN) {
 				 if (match(sobj->model.class, obptr->model.class)) {
-				    while (sobj->next->type > FIRSTPIN)
+				    while (sobj->next && (sobj->next->type > FIRSTPIN))
 				       sobj = sobj->next;
 				    /* Stop when reaching the current instance */
 				    if (sobj->type == obptr->type + 1) break;
@@ -2242,8 +2367,19 @@ char *ReadVerilogTop(char *fname, int *fnum, int blackbox)
      hashfunc = hashcase;
   }
 
-  InitializeHashTable(&verilogparams, OBJHASHSIZE);
-  InitializeHashTable(&verilogdefs, OBJHASHSIZE);
+  if ((hashfile != -1) && (hashfile != *fnum)) {
+      /* Started a new file, so remove all the parameters and definitions */
+      RecurseHashTable(&verilogparams, freeprop);
+      HashKill(&verilogparams);
+      RecurseHashTable(&verilogdefs, freeprop);
+      HashKill(&verilogdefs);
+      hashfile = -1;
+  }
+  if (hashfile == -1) {
+      InitializeHashTable(&verilogparams, OBJHASHSIZE);
+      InitializeHashTable(&verilogdefs, OBJHASHSIZE);
+      hashfile = *fnum;
+  }
   definitions = &verilogdefs;
 
   /* Add the pre-defined key "LVS" to verilogdefs */
@@ -2263,10 +2399,6 @@ char *ReadVerilogTop(char *fname, int *fnum, int blackbox)
   // Cleanup
   while (CellStack != NULL) PopStack(&CellStack);
 
-  RecurseHashTable(&verilogparams, freeprop);
-  HashKill(&verilogparams);
-  RecurseHashTable(&verilogdefs, freeprop);
-  HashKill(&verilogdefs);
   definitions = (struct hashdict *)NULL;
 
   // Record the top level file.

tcltk/tclnetgen.c

@@ -2095,8 +2095,9 @@ _netcmp_compare(ClientData clientData,
    int dohierarchy = FALSE;
    int assignonly = FALSE;
    int argstart = 1, qresult, llen, result;
+   int hascontents1, hascontents2;
    struct Correspond *nextcomp;
-   struct nlist *tp;
+   struct nlist *tp1 = NULL, *tp2 = NULL;
    Tcl_Obj *flist = NULL;
 
    if (objc > 1) {
@@ -2139,24 +2140,24 @@ _netcmp_compare(ClientData clientData,
       }
       else if ((objc - argstart) == 2) {
 
-	 result = CommonParseCell(interp, objv[argstart], &tp, &fnum1);
+	 result = CommonParseCell(interp, objv[argstart], &tp1, &fnum1);
          if (result != TCL_OK) return TCL_ERROR;
 	 else if (fnum1 == -1) {
 	    Tcl_SetResult(interp, "Cannot use wildcard with compare command.\n",
 			NULL);
 	    return TCL_ERROR;
 	 }
-         name1 = tp->name;
+         name1 = tp1->name;
 	 argstart++;
 
-	 result = CommonParseCell(interp, objv[argstart], &tp, &fnum2);
+	 result = CommonParseCell(interp, objv[argstart], &tp2, &fnum2);
          if (result != TCL_OK) return TCL_ERROR;
 	 else if (fnum2 == -1) {
 	    Tcl_SetResult(interp, "Cannot use wildcard with compare command.\n",
 			NULL);
 	    return TCL_ERROR;
 	 }
-         name2 = tp->name;
+         name2 = tp2->name;
 
          if (dohierarchy) {
 	    RemoveCompareQueue();
@@ -2195,12 +2196,34 @@ _netcmp_compare(ClientData clientData,
       ConvertGlobals(name2, fnum2);
    }
 
-   CreateTwoLists(name1, fnum1, name2, fnum2, dolist);
-   while (PrematchLists(name1, fnum1, name2, fnum2) > 0) {
-      Fprintf(stdout, "Making another compare attempt.\n");
-      Printf("Flattened mismatched instances and attempting compare again.\n");
-      CreateTwoLists(name1, fnum1, name2, fnum2, dolist);
+   tp1 = LookupCellFile(name1, fnum1);
+   tp2 = LookupCellFile(name2, fnum2);
+
+   hascontents1 = HasContents(tp1);
+   hascontents2 = HasContents(tp2);
+
+   if (hascontents1 && !hascontents2 && (tp2->flags & CELL_PLACEHOLDER)) {
+       Fprintf(stdout, "Circuit 2 cell %s is a black box; will not flatten "
+                        "Circuit 1\n", name2);
    }
+   else if (hascontents2 && !hascontents1 && (tp1->flags & CELL_PLACEHOLDER)) {
+       Fprintf(stdout, "Circuit 1 cell %s is a black box; will not flatten "
+                        "Circuit 2\n", name1);
+   }
+   else if (hascontents1 || hascontents2) {
+       FlattenUnmatched(tp1, name1, 1, 0);
+       FlattenUnmatched(tp2, name2, 1, 0);
+       DescribeContents(name1, fnum1, name2, fnum2);
+
+       while (PrematchLists(name1, fnum1, name2, fnum2) > 0) {
+          Fprintf(stdout, "Making another compare attempt.\n");
+          Printf("Flattened mismatched instances and attempting compare again.\n");
+          FlattenUnmatched(tp1, name1, 1, 0);
+          FlattenUnmatched(tp2, name2, 1, 0);
+          DescribeContents(name1, fnum1, name2, fnum2);
+       }
+   }
+   CreateTwoLists(name1, fnum1, name2, fnum2, dolist);
 
    // Return the names of the two cells being compared, if doing "compare
    // hierarchical".  If "-list" was specified, then append the output
@@ -3032,11 +3055,11 @@ _netcmp_equate(ClientData clientData,
 			(tp2->flags & CELL_PLACEHOLDER)) {
 		if (tp1->flags & CELL_PLACEHOLDER) {
 		    Fprintf(stdout, "Warning: Equate pins:  cell %s "
-			"has no definition, treated as a black box.\n", name1);
+			"is a placeholder, treated as a black box.\n", name1);
 		}
 		if (tp2->flags & CELL_PLACEHOLDER) {
 		    Fprintf(stdout, "Warning: Equate pins:  cell %s "
-			"has no definition, treated as a black box.\n", name2);
+			"is a placeholder, treated as a black box.\n", name2);
 		}
 		// If a cell in either circuit is marked as a black box, then
 		// the cells in both circuits should be marked as a black box.