Merge branch 'master' into netgen-1.5

method for flattening a subcircuit with property M != 1.

VERSION

@@ -1 +1 @@
-1.5.241
+1.5.253

base/flatten.c

@@ -536,11 +536,10 @@ int flattenInstancesOf(char *name, int fnum, char *instance)
 
          /* Do property inheritance */
 
-         /* NOTE:  Need to do:  Check properties for M > 1 and decrement
-          * and repeat without moving CurrentProp
-          */
-
          if (CurrentProp) {
+	    int i, mval;
+	    struct valuelist *kv;
+
             for (ob2 = ChildStart; ob2 != NULL; ob2=ob2->next) {
 
 	       /* If the parent cell has properties to declare, then	*/
@@ -548,10 +547,49 @@ int flattenInstancesOf(char *name, int fnum, char *instance)
 	       /* spiceparams dictionary is active (during file		*/
 	       /* reading only).					*/
 
-	       if (ob2->type == PROPERTY)
+	       if (ob2->type == PROPERTY) {
 		  ReduceExpressions(ob2, CurrentProp, ChildCell,
 				(spiceparams.hashtab == NULL) ? 0 : 1);
-            }
+	       }
+	    }
+
+	    /* Check for property M.  If it exists and is greater than	*/
+	    /* one, reduce it and repeat;  i.e., generate multiple	*/
+	    /* child instances to match the M value.  Probably this	*/
+	    /* could be done quicker by just creating a new property	*/
+	    /* M for a single child.					*/
+
+	    mval = 0;
+	    for (i = 0; ; i++) {
+	       kv = &(CurrentProp->instance.props[i]);
+	       if (kv->type == PROP_ENDLIST) break;
+	       if ((*matchfunc)(kv->key, "M")) {
+		   if (kv->type == PROP_INTEGER) {
+		      mval = kv->value.ival;
+		      kv->value.ival = mval - 1;
+		      break;
+		   }
+		   else if (kv->type == PROP_DOUBLE) {
+		      mval = (int)kv->value.dval;
+		      kv->value.dval = (double)mval - 1;
+		      break;
+		   }
+	       }
+	    }
+	    if (mval > 1) {
+	       /* Put the child cell at the start of ChildObjList */
+	       if (ChildEnd) {
+	          ChildEnd->next = ChildObjList;
+	          ChildObjList = ChildStart;
+	
+	          /* Continue without moving CurrentProp */
+		  /* Note that if ChildEnd is NULL then the child cell
+		   * is optimized out and there is no need to do it
+		   * M times.
+		   */
+	          continue;
+	       }
+	    }
 
             /* Repeat for each property record, as each property represents a
              * unique instance that must be flattened individually.
@@ -1929,6 +1967,16 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 
 					if (ecomp->cell1->class != CLASS_ISOURCE) {
 					    /* merge node of endpoints */
+					    /* Prefer a port node over a non-port node */
+					    for (ob2 = tc1->cell; ob2; ob2 = ob2->next) {
+						if (!IsPort(ob2)) break;
+						else if (ob2->node == node1) break;
+						else if (ob2->node == node2) {
+						    int ntemp = node1;
+						    node1 = node2;
+						    node2 = ntemp;
+						}
+					    }
 					    for (ob2 = tc1->cell; ob2; ob2 = ob2->next) {
 						if (ob2->node == node2)
 						    ob2->node = node1;
@@ -2037,6 +2085,16 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 
 					/* merge node of endpoints */
 					if (ecomp->cell2->class != CLASS_ISOURCE) {
+					    /* Prefer a port node over a non-port node */
+					    for (ob1 = tc2->cell; ob1; ob1 = ob1->next) {
+						if (!IsPort(ob1)) break;
+						else if (ob1->node == node1) break;
+						else if (ob1->node == node2) {
+						    int ntemp = node1;
+						    node1 = node2;
+						    node2 = ntemp;
+						}
+					    }
 					    for (ob1 = tc2->cell; ob1; ob1 = ob1->next) {
 						if (ob1->node == node2)
 						    ob1->node = node1;

base/inetcomp.c

@@ -17,6 +17,7 @@ along with this program; see the file copying.  If not, write to
 the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
 /* inetcomp.c -- a simple wrapper to the NETCOMP() function */
+#include "config.h"
 
 #include <stdio.h>
 #include "netgen.h"

base/netcmp.c

@@ -17,7 +17,6 @@ along with this program; see the file copying.  If not, write to
 the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
 /* netcmp.c  -- graph isomorphism testing */
-
 #include "config.h"
 
 #include <stdio.h>
@@ -162,6 +161,10 @@ int right_col_end = 87;
 /* if TRUE, always partition ALL classes */
 int ExhaustiveSubdivision = 0;
 
+/* if TRUE, enforce that networks (e.g., resistor) must match	*/
+/* topologically, as opposed to just matching numerically.	*/
+int ExactTopology = 0;
+
 #ifdef TEST
 static void PrintElement_List(struct Element *E)
 {
@@ -4214,7 +4217,11 @@ void series_sort(struct objlist *ob1, struct nlist *tp1, int idx1, int run)
    struct property *kl;
    struct valuelist *vl, *sl;
    int i, p, sval, merge_type;
-   double cval, slop;
+   // double cval, slop;
+   int has_crit;
+   char ca, co;
+   double tval, tslop;
+   double aval, pval, oval, aslop, pslop;
 
    obn = ob1->next;
    for (i = 0; i < idx1; i++) obn = obn->next;
@@ -4227,55 +4234,94 @@ void series_sort(struct objlist *ob1, struct nlist *tp1, int idx1, int run)
 
    obp = obn;
    sval = 1;
-   cval = slop = 0.0;
+   pval = aval = oval = 0.0;
    for (i = 0; i < run; i++) {
-      sl = NULL;
+      has_crit = FALSE;
       merge_type = MERGE_NONE;
+      ca = co = (char)0;
+
       for (p = 0;; p++) {
 	 vl = &(obp->instance.props[p]);
 	 if (vl->type == PROP_ENDLIST) break;
 	 if (vl->key == NULL) continue;
          if ((*matchfunc)(vl->key, "S")) {
 	    sval = vl->value.ival;
-	    sl = vl;
+	    continue;
+	 }
+         kl = (struct property *)HashLookup(vl->key, &(tp1->propdict));
+	 if (kl == NULL) continue;		/* Ignored property */
+
+	 /* Get the property value and slop.  Promote if needed.  Save	*/
+	 /* property and slop as type double so they can be sorted.	*/
+
+	 if ((vl->type == PROP_STRING || vl->type == PROP_EXPRESSION) &&
+		  	(kl->type != vl->type))
+	    PromoteProperty(kl, vl, obp, tp1);
+	 if (vl->type == PROP_INTEGER) {
+	    tval = (double)vl->value.ival;
+	    tslop = (double)kl->slop.ival;
+	 }
+	 else if (vl->type == PROP_STRING) {
+	    /* This is unlikely---no method to merge string properties! */
+	    tval = (double)vl->value.string[0]
+			+ (double)vl->value.string[1] / 10.0;
+	    tslop = (double)0;
 	 }
 	 else {
-	    kl = (struct property *)HashLookup(vl->key, &(tp1->propdict));
-	    if (kl && (kl->merge & (MERGE_S_ADD | MERGE_S_PAR))) {
-		if (vl->type == PROP_INTEGER) {
-		   cval = (double)vl->value.ival;
-		   slop = (double)kl->slop.ival;
-		}
-		else {
-		   cval = vl->value.dval;
-		   slop = kl->slop.dval;
-		}
-	 	merge_type = kl->merge & (MERGE_S_ADD | MERGE_S_PAR);
+	    tval = vl->value.dval;
+	    tslop = kl->slop.dval;
+	 }
+
+	 if (kl->merge & MERGE_S_CRIT) {
+	    has_crit = TRUE;
+	    pval = tval;
+	    pslop = tslop;
+	 }
+	 else if (kl->merge & (MERGE_S_ADD | MERGE_S_PAR)) {
+	    if ((ca == (char)0) || (toupper(vl->key[0]) > ca)) {
+	       merge_type = kl->merge & (MERGE_S_ADD | MERGE_S_PAR);
+	       aval = tval;
+	       aslop = tslop;
+	       ca = toupper(vl->key[0]);
 	    }
 	 }
+	 else if ((co == (char)0) || (toupper(vl->key[0]) > co)) {
+	    oval = tval;
+	    co = toupper(vl->key[0]);
+	 }
       }
-      if (merge_type == MERGE_S_ADD) {
-	 proplist[i].value = cval * (double)sval;
-         proplist[i].slop = slop;
-         proplist[i].avalue = 0;
-	 if (sl) sl->value.ival = 1;
-      }
-      else if (merge_type == MERGE_S_PAR) {
-	 proplist[i].value = cval / (double)sval;
-         proplist[i].slop = slop;
-         proplist[i].avalue = 0;
-	 if (sl) sl->value.ival = 1;
+      if (has_crit == TRUE) {
+	 /* If there is a critical value, then sort first   */
+	 /* by critical value				    */
+	 proplist[i].value = pval;
+	 proplist[i].slop = pslop;
+
+	 /* then sort on additive value times S	*/
+	 /* or on non-additive value.		*/
+         if (merge_type == MERGE_S_ADD)
+	    proplist[i].avalue = aval * (double)sval;
+         else if (merge_type == MERGE_S_PAR)
+	    proplist[i].avalue = aval / (double)sval;
+	 else
+	    proplist[i].avalue = (double)sval;
       }
       else {
-	 /* Components which declare no series addition method stay unsorted */
-	 proplist[i].value = (double)0;
-	 proplist[i].avalue = (double)0;
-         proplist[i].slop = (double)1E-6;
+         if (merge_type != MERGE_NONE) {
+	    proplist[i].value = aval;
+	    proplist[i].slop = aslop;
+	    proplist[i].avalue = (double)sval;
+	 }
+	 else {
+	    proplist[i].value = (double)sval;
+	    proplist[i].slop = (double)0;
+	    proplist[i].avalue = oval;
+	 }
       }
       proplist[i].idx = i;
       proplist[i].ob = obp;
       obp = obp->next;
    }
+
    obn = obp;	/* Link from last property */
 
    qsort(&proplist[0], run, sizeof(propsort), compsort);
@@ -4598,8 +4644,8 @@ void PropertySortAndCombine(struct objlist *pre1, struct nlist *tp1,
       /* and manage the topology.  Note that at this point devices have	   */
       /* already been combined if all critical properties match, so any	   */
       /* parallel devices remaining are not considered mergeable unless as */
-      /* a last resort.  Parallel devices need to be checked for swapping, */
-      /* however.  So the steps are:					   */
+      /* a last resort.  Devices also need to be checked for swapping.	   */
+      /* So the steps are:					   	   */
       /* 1) Find parallel devices with more elements in one circuit than   */
       /*    in the other.  If non-summing parameters of interest match,	   */
       /*    then merge all devices that can be merged until both sides	   */
@@ -4612,6 +4658,10 @@ void PropertySortAndCombine(struct objlist *pre1, struct nlist *tp1,
       /*    circuits.  Check if critical parameters match between the 	   */
       /*    circuits.  If not, check if swapping devices in circuit1	   */
       /*    makes a better match to circuit2.			  	   */
+      /* 4) Find series devices that have the same number in both 	   */
+      /*    circuits.  Check if critical parameters match between the 	   */
+      /*    circuits.  If not, check if swapping devices in circuit1	   */
+      /*    makes a better match to circuit2.			  	   */
 
       /* Case 1:  Parallel devices with more elements in one circuit	*/
 
@@ -4885,13 +4935,17 @@ int PropertyOptimize(struct objlist *ob, struct nlist *tp, int run, int series,
 	    }
 	 }
 	 if (kl == NULL) {
-	    /* Prevent setting both M > 1 and S > 1 in any one	*/
-	    /* device, as it is ambiguous.			*/
+	    /* Setting both M > 1 and S > 1 is topologically	*/
+	    /* ambiguous.  If global option ExactTopology is	*/
+	    /* enabled, then this will cause a failure.  	*/
+	    /* Otherwise, it is allowed.			*/
 
-	    if ((*matchfunc)(vl->key, other)) {
-	       if (vl->type == PROP_INTEGER)
-		  if (vl->value.ival > 1)
-		     fail = 1;
+	    if (ExactTopology) {
+		if ((*matchfunc)(vl->key, other)) {
+		    if (vl->type == PROP_INTEGER)
+			if (vl->value.ival > 1)
+			    fail = 1;
+		}
 	    }
 	 }
  	 else if (kl != NULL) {
@@ -5182,7 +5236,7 @@ int PropertyOptimize(struct objlist *ob, struct nlist *tp, int run, int series,
 		}
 	    }
 	 }
-	 if (changed > 0) {
+  	 if ((Debug == TRUE) && (changed > 0)) {
 	    if (series)
 		Printf("Combined %d series devices.\n", changed);
 	    else
@@ -5317,13 +5371,14 @@ void
 #endif
 PropertyCheckMismatch(struct objlist *tp1, struct nlist *tc1,
 	char *inst1, struct objlist *tp2, struct nlist *tc2,
-	char *inst2, int do_print, int do_list, int *count,
-	int *rval)
+	char *inst2, struct Element *E1, struct Element *E2,
+	int do_print, int do_list, int *count, int *rval)
 {
    int mismatches = 0;
    int len2, *check2;
    struct property *kl1, *kl2, *klt;
    struct valuelist *vl1, *vl2;
+   char *vl1key;
    int i, j;
    int islop;
    int ival1, ival2;
@@ -5427,22 +5482,71 @@ PropertyCheckMismatch(struct objlist *tp1, struct nlist *tc1,
 	 }
       }
 
+      /* If the property is associated with a pin, then		*/
+      /* determine if the pin is permutable;  If so, then	*/
+      /* determine if the pins are swapped between the two	*/
+      /* elements.  If so, then swap the property keys.		*/
+
+      vl1key = vl1->key;
+      if (kl1->pin != NULL) {
+	 struct objlist *tob1, *tob2;
+	 struct NodeList *nl1, *nl2;
+	 struct property *kla;
+	 struct valuelist *vla;
+         int k;
+
+	 nl1 = E1->nodelist;
+	 for (tob1 = tc1->cell; tob1 && tob1->type == PORT; tob1 = tob1->next) {
+	     if ((*matchfunc)(tob1->name, kl1->pin)) break;
+	     nl1 = nl1->next;
+	 }
+	 if (tob1->type == PORT) {
+	     /* Found the node list record corresponding to the given pin. */
+	     /* Now find the pin corresponding to the matching node. */
+	     nl2 = E2->nodelist;
+	     for (tob2 = tc1->cell; tob2 && tob2->type == PORT; tob2 = tob2->next) {
+		if (nl2->node->nodeclass == nl1->node->nodeclass) break;
+	     	nl2 = nl2->next;
+	     }
+	     if (nl2->node->nodeclass == nl1->node->nodeclass) {
+		 if (tob2 != tob1) {	/* Element pins were swapped */
+		    /* Find the other property to swap with */
+		    for (k = 0;; k++) {
+         		vla = &(tp1->instance.props[k]);
+	 		if (vla->type == PROP_ENDLIST) break;
+			if (vla != vl1) {
+	       		    kla = (struct property *)HashLookup(vla->key,
+					&(tc1->propdict));
+			    if (kla && kla->pin)
+	     		        if ((*matchfunc)(tob2->name, kla->pin))
+				    break;
+			}
+		    }
+		    if (vla->type != PROP_ENDLIST) {
+			/* Swap vla->key and vl1->key */
+			vl1key = vla->key;
+		    }
+		 }
+	     }
+	 }
+      }
+
       /* Find the matching property in vl2. */
 
       for (j = 0;; j++) {
          vl2 = &(tp2->instance.props[j]);
 	 if (vl2->type == PROP_ENDLIST) break;
 	 if (check2[j] == 0)
-	    if ((*matchfunc)(vl1->key, vl2->key)) break;
+	    if ((*matchfunc)(vl1key, vl2->key)) break;
       }
       if (vl2->type == PROP_ENDLIST) {
 	 /* Check against M and S records;  a missing M or S	*/
 	 /* record is equivalent to M = 1 or S = 1.		*/
 
 	 if (vl1 != &mvl)
-	    if ((*matchfunc)(vl1->key, mvl.key)) vl2 = &mvl;
+	    if ((*matchfunc)(vl1key, mvl.key)) vl2 = &mvl;
 	 if (vl1 != &svl)
-	    if ((*matchfunc)(vl1->key, svl.key)) vl2 = &svl;
+	    if ((*matchfunc)(vl1key, svl.key)) vl2 = &svl;
       }
       if (vl2->type == PROP_ENDLIST) {
 	 /* vl1 had a property of interest that was not found	*/
@@ -5451,7 +5555,7 @@ PropertyCheckMismatch(struct objlist *tp1, struct nlist *tc1,
          if (do_print) {
 	    Fprintf(stdout, "%s vs. %s:\n", inst1, inst2);
 	    Fprintf(stdout, "Property %s in circuit1 has no matching "
-			"property in circuit2\n",  vl1->key);
+			"property in circuit2\n",  vl1key);
 	 }
 #ifdef TCL_NETGEN
          if (do_list) {
@@ -6095,7 +6199,7 @@ PropertyMatch(struct Element *E1, struct Element *E2,
       else {
 	 int multmatch, count;
 	 PropertyCheckMismatch(tp1, tc1, inst1, tp2, tc2,
-			inst2, FALSE, FALSE, &multmatch, NULL);
+			inst2, E1, E2, FALSE, FALSE, &multmatch, NULL);
 	 if (multmatch == 1) {
 	    /* Final attempt:  Reduce M to 1 on both devices */
 	    run1 = run2 = 0;
@@ -6116,7 +6220,7 @@ PropertyMatch(struct Element *E1, struct Element *E2,
 	 mlist =
 #endif
 	 PropertyCheckMismatch(tp1, tc1, inst1, tp2, tc2,
-			inst2, do_print, do_list, &count, &rval);
+			inst2, E1, E2, do_print, do_list, &count, &rval);
 	 mismatches += count;
 #ifdef TCL_NETGEN
 	 if (do_list && (mlist != NULL)) {
@@ -6964,12 +7068,15 @@ int IgnoreClass(char *name, int file, unsigned char type)
 /* If file1 and file2 are -1, then these are names to	*/
 /* be checked as netcmp works through the hierarchy.  	*/
 /* Otherwise, look up the structure for each file and	*/
-/* set the classhash of the second to that of the first	*/
+/* set the classhash of the second to that of the	*/
+/* first.  If "dounique" is 1, then give the two cells	*/
+/* their own class hash;  they will not be compared	*/
+/* any other cells in either netlist.			*/
 /*							*/
 /* Return 1 on success, 0 on failure			*/
 /*------------------------------------------------------*/
 
-int EquivalenceClasses(char *name1, int file1, char *name2, int file2)
+int EquivalenceClasses(char *name1, int file1, char *name2, int file2, int dounique)
 {
    char *class1, *class2;
    struct Correspond *newc;
@@ -6994,16 +7101,19 @@ int EquivalenceClasses(char *name1, int file1, char *name2, int file2)
       if (tp->flags & CELL_DUPLICATE)
 	 reverse = 1;
 
-      /* Do a cross-check for each name in the other netlist.  If 	*/
-      /* conflicting names exist, then alter the classhash to make it	*/
-      /* unique.  In the case of duplicate cells, don't do this.	*/
+      if (dounique) {
 
-      if (!(tp->flags & CELL_DUPLICATE) && !(tp2->flags & CELL_DUPLICATE) &&
+	 /* Do a cross-check for each name in the other netlist.  If 	*/
+	 /* conflicting names exist, then alter the classhash to make 	*/
+	 /* it unique.  In the case of duplicate cells, don't do this.	*/
+
+	 if (!(tp->flags & CELL_DUPLICATE) && !(tp2->flags & CELL_DUPLICATE) &&
 			!(*matchfunc)(name1, name2)) {
-	 tpx = LookupCellFile(name1, file2);
-	 if (tpx != NULL) need_new_seed = 1;
-	 tpx = LookupCellFile(name2, file1);
-	 if (tpx != NULL) need_new_seed = 1;
+	    tpx = LookupCellFile(name1, file2);
+	    if (tpx != NULL) need_new_seed = 1;
+	    tpx = LookupCellFile(name2, file1);
+	    if (tpx != NULL) need_new_seed = 1;
+	 }
       }
 
       /* Now make the classhash values the same so that these cells	*/

base/netcmp.h

@@ -7,6 +7,7 @@ extern struct nlist *Circuit1;
 extern struct nlist *Circuit2;
 
 extern int ExhaustiveSubdivision;
+extern int ExactTopology;
 
 extern int left_col_end;
 extern int right_col_end;
@@ -37,7 +38,8 @@ extern int PermuteSetup(char *model, int filenum, char *pin1, char *pin2);
 extern int PermuteForget(char *model, int filenum, char *pin1, char *pin2);
 extern int EquivalenceElements(char *name1, int file1, char *name2, int file2);
 extern int EquivalenceNodes(char *name1, int file1, char *name2, int file2);
-extern int EquivalenceClasses(char *name1, int file1, char *name2, int file2);
+extern int EquivalenceClasses(char *name1, int file1, char *name2, int file2,
+		int dounique);
 extern int IgnoreClass(char *name, int file, unsigned char type);
 extern int MatchPins(struct nlist *tp1, struct nlist *tp2, int dolist);
 extern int PropertyOptimize(struct objlist *ob, struct nlist *tp, int run,

base/netfile.c

@@ -183,7 +183,6 @@ void CloseFile(char *filename)
 		fclose(outfile);
 }
 
-
 /* STUFF TO READ INPUT FILES */
 
 static char *line = NULL;	/* actual line read in */
@@ -207,6 +206,21 @@ struct hashdict *definitions = (struct hashdict *)NULL;
 
 #define WHITESPACE_DELIMITER " \t\n\r"
 
+/*----------------------------------------------------------------------*/
+/* Seek and Tell on infile stream, for use with handling generate	*/
+/* loops in verilog.							*/
+/*----------------------------------------------------------------------*/
+
+void SeekFile(long offset)
+{
+    fseek(infile, offset, SEEK_SET);
+}
+
+long TellFile()
+{
+    return ftell(infile);
+}
+
 /*----------------------------------------------------------------------*/
 /* TrimQuoted() ---							*/
 /* Remove spaces from inside single- or double-quoted strings.		*/

base/netfile.h

@@ -47,5 +47,7 @@ extern void InputParseError(FILE *f);
 extern int OpenParseFile(char *name, int fnum);
 extern int EndParseFile(void);
 extern int CloseParseFile(void);
+extern void SeekFile(long offset);	/* handles verilog 'for' loops */
+extern long TellFile();			/* handles verilog 'for' loops */
 
 #endif /* _NETFILE_H */

base/netgen.c

@@ -984,6 +984,51 @@ PropertyDelete(char *name, int fnum, char *key)
     return 0;
 }
 
+/*----------------------------------------------------------------------*/
+/* Associate a property with a specific pin				*/
+/*----------------------------------------------------------------------*/
+
+int
+PropertyAssociatePin(char *name, int fnum, char *key, char *pin)
+{
+    struct property *kl = NULL;
+    struct nlist *tc;
+    struct objlist *ob;
+    int result;
+
+    if ((fnum == -1) && (Circuit1 != NULL) && (Circuit2 != NULL)) {
+	result = PropertyAssociatePin(name, Circuit1->file, key, pin);
+	result = PropertyAssociatePin(name, Circuit2->file, key, pin);
+	return result;
+    }
+
+    tc = LookupCellFile(name, fnum);
+    if (tc == NULL) {
+	Printf("No device %s found for PropertyAssociatePin()\n", name);
+	return -1;
+    }
+
+    kl = (struct property *)HashLookup(key, &(tc->propdict));
+    if (kl == NULL) {
+	Printf("No property %s found for device %s\n", key, name);
+	return -1;
+    }
+    else {
+        for (ob = tc->cell; ob != NULL; ob = ob->next) {
+	    if (ob->type != PORT) break;
+	    else if ((*matchfunc)(ob->name, pin)) {
+		kl->pin = ob->name;
+		break;
+	    }
+        }
+	if (ob == NULL) {
+	    Printf("No pin %s found for device %s\n", pin, name);
+	    return -1;
+	}
+    }
+    return 0;
+}
+
 /*----------------------------------------------------------------------*/
 /* Set the tolerance of a property in the master cell record.		*/
 /*----------------------------------------------------------------------*/

base/netgen.h

@@ -39,6 +39,7 @@ extern void SetParallelCombine(int value);
 extern void SetSeriesCombine(int value);
 extern int  PropertyTolerance(char *name, int fnum, char *key, int ival,
 		double dval);
+extern int  PropertyAssociatePin(char *name, int fnum, char *key, char *pin);
 extern int  PropertyMerge(char *name, int fnum, char *key, int merge_type,
 		int merge_mask);
 extern void ResolveProperties(char *name1, int file1, char *name2, int file2);

base/objlist.c

@@ -130,6 +130,7 @@ struct property *NewProperty(void)
 	
 	kl = (struct property *)CALLOC(1,sizeof(struct property));
 	if (kl == NULL) Fprintf(stderr,"NewProperty: Core allocation error\n");
+	kl->pin = (char *)NULL;
 	return (kl);
 }
 
@@ -440,13 +441,6 @@ void RemoveShorted(char *class, int file)
    RecurseCellFileHashTable(removeshorted, file);
 }
 
-/* Structure used to keep track of nodes needing checking */
-
-struct linkednode {
-    int node;
-    struct linkednode *next;
-};
-
 /* Remove instances of a deleted class from the database.	*/
 /* NOTE:  This treats deleted classes as not existing, so it	*/
 /* needs to take care of disconnected ports in the same manner	*/
@@ -457,13 +451,22 @@ struct linkednode {
 int deleteclass(struct hashlist *p, int file)
 {
    struct nlist *ptr;
-   struct objlist *ob, *lob, *nob;
-   struct linkednode *checknodes = NULL, *newlnode, *chknode;
+   struct objlist *ob, *lob, *nob, *portnode;
+   unsigned char *checknodes;
+   int i;
 
    ptr = (struct nlist *)(p->ptr);
 
    if ((file != -1) && (ptr->file != file)) return 0;
 
+   /* Note:  This could be made faster by enumerating all times each
+    * node is used during the full pass, then subtracting each time
+    * the node is deleted in a child, then disconnecting all nodes
+    * that ended up with a zero count.
+    */
+   checknodes = (unsigned char *)CALLOC(ptr->nodename_cache_maxnodenum + 1,
+		sizeof(unsigned char));
+
    lob = NULL;
    for (ob = ptr->cell; ob != NULL;) {
       nob = ob->next;
@@ -471,12 +474,8 @@ int deleteclass(struct hashlist *p, int file)
 	 if ((*matchfunc)(ob->model.class, OldCell->name)) {
 	    HashDelete(ob->instance.name, &(ptr->instdict));
 	    while (1) {
-	       if (ob->type >= FIRSTPIN) {
-		  newlnode = (struct linkednode *)MALLOC(sizeof(struct linkednode));
-		  newlnode->node = ob->node;
-		  newlnode->next = checknodes;
-		  checknodes = newlnode;
-	       }
+	       if (ob->type >= FIRSTPIN)
+		  checknodes[ob->node] = (unsigned char)1;
 	       FreeObjectAndHash(ob, ptr);
 	       ob = nob;
 	       if (ob == NULL) break;
@@ -499,26 +498,24 @@ int deleteclass(struct hashlist *p, int file)
       }
    }
 
-   while (checknodes != NULL) {
-      struct objlist *portnode = NULL;
-
-      chknode = checknodes;
-      checknodes = checknodes->next;
-
-      for (ob = ptr->cell; ob != NULL; ob = ob->next) {
-	if ((ob->type != PORT) && (portnode == NULL))
-	   break;
-	else if ((ob->type == PORT) && (ob->node == chknode->node))
-	   portnode = ob;
-	else if ((ob->type >= FIRSTPIN) && (ob->node == chknode->node))
-	   break;
+   for (i = 0; i <= ptr->nodename_cache_maxnodenum; i++) {
+      if (checknodes[i] != 0) {
+         portnode = NULL;
+         for (ob = ptr->cell; ob != NULL; ob = ob->next) {
+	    if ((ob->type != PORT) && (portnode == NULL))
+	       break;
+	    else if ((ob->type == PORT) && (ob->node == i))
+	       portnode = ob;
+	    else if ((ob->type >= FIRSTPIN) && (ob->node == i))
+	       break;
+         }
+         if ((ob == NULL) && (portnode != NULL)) {
+	    /* Port became disconnected when child was deleted */
+	    portnode->node = -1;
+         }
       }
-      if ((ob == NULL) && (portnode != NULL)) {
-	 /* Port became disconnected when child was deleted */
-	 portnode->node = -1;
-      }
-      FREE(chknode);
    }
+   FREE(checknodes);
 }
 
 /* Remove all instances of class "class" from the database */

base/objlist.h

@@ -135,6 +135,7 @@ struct property {
   unsigned char idx;		/* index into valuelist */
   unsigned char type;		/* string, integer, double, value, expression */
   unsigned char merge;		/* how property changes when devices are merged */
+  char *pin;			/* associated pin (or NULL if not associated)	*/
   union {
      char *string;
      double dval;

base/test.c

@@ -34,6 +34,8 @@ the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 #include "print.h"
 #endif
 
+extern void Finsert(FILE *f);
+
 void test_entry(void) 
 { 
 

base/verilog.c

@@ -42,6 +42,7 @@ the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
 #include <stdio.h>
 #include <stdlib.h>  /* for calloc(), free(), getenv() */
+#include <ctype.h>   /* for isalnum() */
 #ifndef IBMPC
 #include <sys/types.h>	/* for getpwnam() tilde expansion */
 #include <pwd.h>
@@ -63,6 +64,7 @@ the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 #define VLOG_EQUATION_DELIMITERS "X///**/#((**)X,;:(){}[]=+-*/"
 #define VLOG_PIN_NAME_DELIMITERS "X///**/(**)X()"
 #define VLOG_PIN_CHECK_DELIMITERS "X///**/(**)X,;(){}"
+#define VLOG_INTEGER_DELIMITERS "X///**/X;[]"
 
 // Used by portelement structure "flags" record.
 #define PORT_NOT_FOUND	0
@@ -83,6 +85,16 @@ struct bus {
     int end;
 };
 
+// Global storage for a 'for' loop
+struct _loop {
+    char *loopvar;
+    int start;
+    int end;
+    long filepos;
+};
+
+struct _loop loop;
+
 // Free a bus structure in the hash table during cleanup
 
 int freebus (struct hashlist *p)
@@ -244,7 +256,16 @@ int EvalExpr(struct expr_stack **stackptr, int *valptr)
 
 	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')) {
+		/* Watch for (a)*b+c or a+b*(c);  multiplies must be solved first */
+		if ((texp->last->last != NULL) && ((texp->last->last->oper == '*')
+				|| (texp->last->last->oper == '/'))) {
+			/* Do nothing */
+		}
+		else if ((texp->next->next != NULL) && ((texp->next->next->oper == '*')
+				|| (texp->next->next->oper == '/'))) {
+			/* Do nothing */
+		}
+		else if ((texp->last->oper == '\0') && (texp->next->oper == '\0')) {
 		    if (texp->oper == '-') {
 			/* Subtract */
 			texp->last->value -= texp->next->value;
@@ -290,6 +311,7 @@ int EvalExpr(struct expr_stack **stackptr, int *valptr)
 		}
 	    }
 	}
+
     }
 
     /* If only one numerical item remains, then place it in valptr and return 1 */
@@ -311,6 +333,134 @@ int EvalExpr(struct expr_stack **stackptr, int *valptr)
     return 0;
 }
 
+//-------------------------------------------------------------------------
+// Parse an expression which must resolve to a single integer.
+// If it does, return "1" and put the integer in the return
+// pointer "iptr".  If not, return "0" and iptr is undefined.
+// The expression may use parameters, standard arithmetic,
+// and parenthetic grouping.  This routine does not tokenize input
+// but assumes that the entire expression is in the string "expr".
+//-------------------------------------------------------------------------
+
+int ParseIntegerExpression(char *expr, int *iptr)
+{
+    int result, value;
+    char *sptr, *cptr, savec;
+    struct property *kl = NULL;
+    struct expr_stack *stack, *newexp;
+
+    stack = NULL;
+    savec = '\0';
+    sptr = expr;
+    result = 1;
+
+    while (sptr && (*sptr != '\0')) {
+	// Move sptr to first non-space character
+	while (isspace(*sptr)) sptr++;
+
+	// Tokenize.  Look ahead to next delimeter and truncate string there.
+	cptr = sptr + 1;
+	if (isalnum(*sptr) || (*sptr == '_') || (*sptr == '$')) {
+	    while (*cptr != '\0') {
+		if (isalnum(*cptr)) cptr++;
+		else if ((*cptr == '_') || (*cptr == '$')) cptr++;
+		else break;
+	    }
+	}
+	savec = *cptr;
+	*cptr = '\0';
+
+	if (match(sptr, "+") || match(sptr, "-")
+	    	|| match(sptr, "*") || match(sptr, "/")
+	    	|| match(sptr, "(") || match(sptr, ")")) {
+	    newexp = (struct expr_stack *)MALLOC(sizeof(struct expr_stack));
+	    newexp->oper = *sptr;
+	    newexp->value = 0;
+	    newexp->next = NULL;
+	    newexp->last = stack;
+	    if (stack) stack->next = newexp;
+	    stack = newexp;
+
+	    sptr = cptr;
+	    *cptr = savec;
+	    continue;
+	}
+	if ((result = sscanf(sptr, "%d", &value)) != 1) {
+
+	    // Is name in the parameter list?
+	    kl = (struct property *)HashLookup(nexttok, &verilogparams);
+	    if (kl == NULL) {
+		Printf("Value %s in expression is not a number or a parameter.\n",
+				sptr);
+		value = 0;
+		break;
+	    }
+	    else {
+		if (kl->type == PROP_STRING) {
+		    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);
+		    	value = 0;
+			break;
+		    }
+		}
+		else if (kl->type == PROP_INTEGER) {
+		    value = kl->pdefault.ival;
+		}
+		else if (kl->type == PROP_DOUBLE) {
+		    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);
+		    value = 0;
+		    break;
+		}
+	    }
+	}
+
+	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;
+
+	/* Move to next token */
+	sptr = cptr;
+	*cptr = savec;
+    }
+
+    if (result != 0) {
+	if (stack == NULL) {
+	    Printf("Empty array found.\n");
+	    result = 0;
+	}
+	else if (EvalExpr(&stack, iptr) != 1) {
+	    Printf("Bad expression found in array.\n");
+	    result = 0;
+	}
+    }
+
+    /* In case of error, stack may need cleaning up */
+    while (stack != NULL) {
+	newexp = stack;
+	stack = stack->last;
+	FREE(newexp);
+    }
+    return result;
+}
+
 //-------------------------------------------------------------------------
 // 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.
@@ -323,7 +473,6 @@ int EvalExpr(struct expr_stack **stackptr, int *valptr)
 int GetBusTok(struct bus *wb)
 {
     int result, start, end, value;
-    char oper;
     struct property *kl = NULL;
     struct expr_stack *stack, *newexp;
 
@@ -338,7 +487,6 @@ int GetBusTok(struct bus *wb)
 
     if (match(nexttok, "[")) {
 	start = end = -1;
-	oper = '\0';
 	while (nexttok) {
 	    SkipTokComments(VLOG_EQUATION_DELIMITERS);
     	    if (match(nexttok, "]")) {
@@ -467,13 +615,16 @@ int GetBusTok(struct bus *wb)
 
 //--------------------------------------------------------------------
 // GetBus() is similar to GetBusTok() (see above), but it parses from
-// a string instead of the input tokenizer.
+// a string instead of the input tokenizer, and expressions are not
+// allowed.
 //--------------------------------------------------------------------
 
 int GetBus(char *astr, struct bus *wb)
 {
     char *colonptr, *brackstart, *brackend, *sigend, sdelim, *aastr;
     int result, start, end;
+    struct property *kl = NULL;
+    struct expr_stack *stack, *newexp;
 
     if (wb == NULL) return 0;
     else {
@@ -531,7 +682,7 @@ int GetBus(char *astr, struct bus *wb)
 	*brackend = '\0';
 	colonptr = strvchr(aastr, ':');
 	if (colonptr) *colonptr = '\0';
-	result = sscanf(brackstart + 1, "%d", &start);
+	result = ParseIntegerExpression(brackstart + 1, &start);
 	if (colonptr) *colonptr = ':';
 	if (result != 1) {
 	    Printf("Badly formed array notation \"%s\"\n", astr);
@@ -539,7 +690,7 @@ int GetBus(char *astr, struct bus *wb)
 	    return 1;
 	}
 	if (colonptr)
-	    result = sscanf(colonptr + 1, "%d", &end);
+	    result = ParseIntegerExpression(colonptr + 1, &end);
 	else {
 	    result = 1;
 	    end = start;        // Single bit
@@ -876,6 +1027,8 @@ void ReadVerilogFile(char *fname, int filenum, struct cellstack **CellStackPtr,
   in_module = (char)0;
   in_param = (char)0;
 
+  loop.loopvar = NULL;
+
   while (!EndParseFile()) {
 
     SkipTokComments(VLOG_DELIMITERS); /* get the next token */
@@ -1416,6 +1569,145 @@ skip_endmodule:
 	while (!match(nexttok, ";")) SkipTok("X///**/X,;");
 	continue;
     }
+    else if (match(nexttok, "end")) {
+	/* Handle a 'for' loop */
+	if (loop.loopvar != NULL) {
+	    int loopval;
+	    struct property *klr;
+
+	    klr = (struct property *)HashLookup(loop.loopvar, &verilogparams);
+	    loopval = klr->pdefault.ival;
+
+	    if (loopval < loop.end) loopval++;
+	    else if (loopval > loop.end) loopval--;
+	    SeekFile(loop.filepos);
+	    if (loopval == loop.end)
+	    {
+		HashDelete(loop.loopvar, &verilogparams);
+		FREE(klr);
+		FREE(loop.loopvar);
+		loop.loopvar = NULL;
+	    }
+	    else
+		klr->pdefault.ival = loopval;
+	}
+	continue;
+    }
+    else if (match(nexttok, "begin") || match(nexttok, "generate")) {
+	/* 'generate' section or 'for' loop start is ignored */
+	continue;
+    }
+    else if (match(nexttok, "generate") || match(nexttok, "endgenerate")) {
+	/* 'generate' section is ignored */
+	continue;
+    }
+    else if (match(nexttok, "genvar")) {
+	while (!match(nexttok, ";")) SkipTok("X///**/X,;");
+	continue;
+    }
+    else if (match(nexttok, "for")) {
+	char limittype = '\0';
+	char *paramkey = NULL;
+	struct property *kl = NULL, *klr;
+	/* Parse out the loop variable and count.  Set the loop
+	 * variable as a parameter.  Find the beginning of the
+	 * loop block and record the file position so that the
+	 * block can be re-parsed for each loop iteration.
+	 */
+	SkipTokNoNewline(VLOG_DELIMITERS);
+	if ((nexttok == NULL) || !match(nexttok, "(")) {
+	    Printf("Badly formed 'for' loop.\n");
+	    FREE(paramkey);
+	    break;
+	}
+	SkipTokNoNewline(VLOG_DELIMITERS);
+	/* Next token must be the loop variable */
+	if (nexttok == NULL) break;
+	paramkey = strsave(nexttok);
+	SkipTokNoNewline(VLOG_DELIMITERS);
+	if (!match(nexttok, "=")) {
+	    Printf("Badly formed 'for' loop.\n");
+	    FREE(paramkey);
+	    break;
+	}
+	SkipTokNoNewline(VLOG_INTEGER_DELIMITERS);
+	if (ParseIntegerExpression(nexttok, &ival) == 0) {
+	    FREE(paramkey);
+	    break;
+	}
+
+	kl = NewProperty();
+	kl->type = PROP_INTEGER;
+	kl->slop.ival = 0;
+	kl->pdefault.ival = ival;
+	kl->key = paramkey;
+	kl->idx = 0;
+	kl->merge = MERGE_NONE;
+
+	SkipTokNoNewline(VLOG_DELIMITERS);
+	if (!match(nexttok, ";")) {
+	    Printf("Badly formed 'for' loop.\n");
+	    FREE(paramkey);
+	    FREE(kl);
+	    break;
+	}
+
+	/* Assuming a standard 'for' loop here */
+	SkipTokNoNewline(VLOG_DELIMITERS);
+	if (!match(nexttok, paramkey)) {
+	    Printf("Don't know how to parse this 'for' loop!\n");
+	    FREE(paramkey);
+	    FREE(kl);
+	    break;
+	}
+	SkipTokNoNewline(VLOG_DELIMITERS);
+	if (strlen(nexttok) == 1) limittype = *nexttok;
+	SkipTokNoNewline(VLOG_INTEGER_DELIMITERS);
+	if (ParseIntegerExpression(nexttok, &ival) == 0) {
+	    FREE(kl);
+	    FREE(paramkey);
+	    break;
+	}
+
+	/* Loops will stop after the last value, so if value is > or <,
+	 * then adjust the end value accordingly.
+	 */
+	if (limittype == '<')
+	    ival--;
+	else if (limittype == '>')
+	    ival++;
+
+	SkipTokNoNewline(VLOG_DELIMITERS);
+	if (!match(nexttok, ";")) {
+	    Printf("Badly formed 'for' loop.\n");
+	    FREE(paramkey);
+	    FREE(kl);
+	    break;
+	}
+
+	/* Assume a standard 'for' loop and skip to the block begin	*/
+	/* To do:  Parse out the loop increment value.			*/
+	while (1) {
+	    SkipTokNoNewline(VLOG_DELIMITERS);
+	    if (EndParseFile()) break;
+	    else if (match(nexttok, "begin")) break;
+	}
+	if (EndParseFile()) {
+	    Printf("Badly formed 'for' loop:  No begin/end block.\n");
+	    FREE(paramkey);
+	    FREE(kl);
+	    break;
+	}
+
+	/* Save the loop variable, ending value, and file position */
+	loop.loopvar = paramkey;
+	loop.start = kl->pdefault.ival;
+	loop.end = ival;
+	loop.filepos = TellFile();
+
+	/* 'for' loop has been completely parsed, so save the loop variable */
+	HashPtrInstall(paramkey, kl, &verilogparams);
+    }
     else if (match(nexttok, "wire") || match(nexttok, "assign")) {	/* wire = node */
 	struct bus wb, wb2, *nb;
 	char nodename[MAX_STR_LEN], noderoot[MAX_STR_LEN];
@@ -1479,7 +1771,7 @@ skip_endmodule:
 	}
 	else {	    /* "assign" */
 	    SkipTokComments(VLOG_PIN_CHECK_DELIMITERS);
-	    if (GetBus(nexttok, &wb) == 0) {
+	    if (GetBusTok(&wb) == 0) {
 		char *aptr = strvchr(nexttok, '[');
 		if (aptr != NULL) {
 		    *aptr = '\0';
@@ -1514,9 +1806,11 @@ skip_endmodule:
 	//    "assign a = b" joins two nets.
 	//    "assign a = {b, c, ...}" creates a bus from components.
 	//    "assign" using any boolean arithmetic is not structural verilog.
+	//    "assign a = {x{b}}" creates a bus by repeating a component.
 
 	if (nexttok && match(nexttok, "=")) {
 	    char assignname[MAX_STR_LEN], assignroot[MAX_STR_LEN];
+	    int multiplier = 1;
 
 	    i = wb.start;
 	    while (1) {
@@ -1525,6 +1819,10 @@ skip_endmodule:
 
 		if (match(nexttok, "{")) {
 		    /* RHS is a bundle */
+		    /* Make provisional multiplier active.  NOTE:	*/
+		    /* this is not going to properly handle complex	*/
+		    /* multipliers like {2{a,b}}.  Needs rework.	*/
+		    if (multiplier < 0) multiplier = -multiplier;
 		    continue;
 		}
 		else if (match(nexttok, "}")) {
@@ -1540,7 +1838,7 @@ skip_endmodule:
 		    break;
 		}
 		else {
-		    if (GetBus(nexttok, &wb2) == 0) {
+		    if (GetBusTok(&wb2) == 0) {
 			char *aptr = strvchr(nexttok, '[');
 			j = wb2.start;
 			if (aptr != NULL) {
@@ -1556,6 +1854,18 @@ skip_endmodule:
 		    else {
 			j = -1;
 			rhs = LookupObject(nexttok, CurrentCell);
+
+			/* Check if rhs starts with a signal multiplier */
+			if (rhs == NULL) {
+			    if (ConvertStringToInteger(nexttok, &multiplier) == 1) {
+				/* Set multiplier to a negative value to
+				 * indicate that it is provisional, waiting on
+				 * signal specification to follow.
+				 */
+				multiplier = -multiplier;
+				continue;
+			    }
+			}
 		    }
 		    if ((lhs == NULL) || (rhs == NULL)) {
 			if (rhs != NULL) {
@@ -1568,7 +1878,7 @@ skip_endmodule:
 			    Printf("Improper expression is \"%s\".\n", nexttok);
 			    break;
 			}
-			if (lhs != NULL) {
+			if ((lhs != NULL) || (multiplier < 0)) {
 			    Printf("Improper assignment;  right-hand side cannot "
 					"be parsed.\n");
 			    if (i != -1)
@@ -1588,21 +1898,27 @@ skip_endmodule:
 			/* until bits in signal are exhausted or LHS is full.	    */
 
 			if (i != -1)
-			    sprintf(nodename, "%s[%d]", noderoot, i);
+			    snprintf(nodename, MAX_STR_LEN, "%s[%d]", noderoot, i);
 			else
-			    sprintf(nodename, lhs->name);
+			    strncpy(nodename, lhs->name, MAX_STR_LEN - 1);
 			if (j != -1)
-			    sprintf(assignname, "%s[%d]", assignroot, j);
+			    snprintf(assignname, MAX_STR_LEN, "%s[%d]", assignroot, j);
 			else
-			    sprintf(assignname, rhs->name);
+			    strncpy(assignname, rhs->name, MAX_STR_LEN - 1);
 
 			join(nodename, assignname);
 
 			if (i == wb.end) break;
 			i += (wb.end > wb.start) ? 1 : -1;
 
-			if (j == wb2.end) break;
-			j += (wb2.end > wb2.start) ? 1 : -1;
+			if (j == wb2.end) {
+			    if (multiplier <= 1)
+			    	break;
+			    else
+				multiplier--;
+			}
+			else
+			    j += (wb2.end > wb2.start) ? 1 : -1;
 		    }
 		}
 	    }
@@ -1810,6 +2126,31 @@ nextinst:
 		     }
 		     new_port->net = wire_bundle;
 		  }
+		  else if ((strchr(nexttok, '[') != NULL) &&
+				(strchr(nexttok, ']') == NULL)) {
+		     /* If a bus expressions has whitespace, then treat it like
+		      * a bundle, above, concatenating to the closing ']'.
+		      */
+		     char *array_expr = (char *)MALLOC(1);
+		     char *new_array_expr = NULL;
+		     *array_expr = '\0';
+		     /* Read to "]" */
+		     while (nexttok) {
+			 new_array_expr = (char *)MALLOC(strlen(array_expr) +
+				    strlen(nexttok) + 1);
+			 /* Roundabout way to do realloc() becase there is no REALLOC() */
+			 strcpy(new_array_expr, array_expr);
+			 strcat(new_array_expr, nexttok);
+			 FREE(array_expr);
+			 array_expr = new_array_expr;
+			 if (strchr(nexttok, ']')) break;
+			 SkipTokComments(VLOG_PIN_CHECK_DELIMITERS);
+		     }
+		     if (!nexttok) {
+			 Printf("Unterminated net in pin %s\n", array_expr);
+		     }
+		     new_port->net = array_expr;
+		  }
 		  else if (nexttok[0] == '~' || nexttok[0] == '!' || nexttok[0] == '-') {
 		     /* All of these imply that the signal is logically manipulated */
 		     /* in turn implying behavioral code.			    */

netgen/inetcomp.c

@@ -17,6 +17,7 @@ along with this program; see the file copying.  If not, write to
 the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
 /* inetcomp.c -- a simple wrapper to the NETCOMP() function */
+#include "config.h"
 
 #include <stdio.h>
 #include "netgen.h"

netgen/netcomp.c

@@ -17,6 +17,7 @@ along with this program; see the file copying.  If not, write to
 the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
 /* netcomp.c -- a simple wrapper to provide netlist comparison functionality */
+#include "config.h"
 
 #include <stdio.h>
 #include "netgen.h"

netgen/netgen_main.c

@@ -23,6 +23,7 @@ the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 #include <stdlib.h>  /* for getenv */
 #endif
 #include "netgen.h"
+#include "print.h"
 
 int main(int argc, char **argv)
 {

netgen/ntk2xnf.c

@@ -20,9 +20,11 @@ along with this program; see the file copying.  If not, write to
 the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
 /* ntk2xnf.c  -- a simple wrapper to translate .ntk to Xilinx XNF format */
+#include "config.h"
 
 #include <stdio.h>
 #include "netgen.h"
+#include "xilinx.h"
 
 #ifdef HAVE_X11
 /* the following two X procedures are to permit linking

scripts/configure

@@ -712,6 +712,7 @@ infodir
 docdir
 oldincludedir
 includedir
+runstatedir
 localstatedir
 sharedstatedir
 sysconfdir
@@ -794,6 +795,7 @@ datadir='${datarootdir}'
 sysconfdir='${prefix}/etc'
 sharedstatedir='${prefix}/com'
 localstatedir='${prefix}/var'
+runstatedir='${localstatedir}/run'
 includedir='${prefix}/include'
 oldincludedir='/usr/include'
 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
@@ -1046,6 +1048,15 @@ do
   | -silent | --silent | --silen | --sile | --sil)
     silent=yes ;;
 
+  -runstatedir | --runstatedir | --runstatedi | --runstated \
+  | --runstate | --runstat | --runsta | --runst | --runs \
+  | --run | --ru | --r)
+    ac_prev=runstatedir ;;
+  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
+  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
+  | --run=* | --ru=* | --r=*)
+    runstatedir=$ac_optarg ;;
+
   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
     ac_prev=sbindir ;;
   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
@@ -1183,7 +1194,7 @@ fi
 for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
 		datadir sysconfdir sharedstatedir localstatedir includedir \
 		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
-		libdir localedir mandir
+		libdir localedir mandir runstatedir
 do
   eval ac_val=\$$ac_var
   # Remove trailing slashes.
@@ -1336,6 +1347,7 @@ Fine tuning of the installation directories:
   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
   --libdir=DIR            object code libraries [EPREFIX/lib]
   --includedir=DIR        C header files [PREFIX/include]
   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
@@ -6065,7 +6077,6 @@ fi
 
 
 if test $usingTcl ; then
-  usingX11=1
   cadinstall="$cadinstall tcltk"
   modules="$modules tcltk"
   programs="$programs tcltk"
@@ -6075,7 +6086,11 @@ if test $usingTcl ; then
 
   extra_libs="$extra_libs \${NETGENDIR}/tcltk/libtcltk.o"
   extra_defs="$extra_defs -DTCL_DIR=\\\"\${TCLDIR}\\\""
-  stub_defs="$stub_defs -DUSE_TCL_STUBS -DUSE_TK_STUBS"
+  if test $usingX11 ; then
+    stub_defs="$stub_defs -DUSE_TCL_STUBS"
+  else
+    stub_defs="$stub_defs -DUSE_TCL_STUBS -DUSE_TK_STUBS"
+  fi
 else
   programs="$programs netgen"
   unused="$unused tcltk"
@@ -6160,6 +6175,7 @@ if test $usingTcl ; then
 # Tk libraries and header files
 #
 # -----------------------------------------------------------------------
+if test $usingX11 ; then
   if test "${TK_INC_DIR}" != "/usr/include" ; then
     INC_SPECS="${INC_SPECS} -I${TK_INC_DIR}"
   fi
@@ -6176,6 +6192,7 @@ if test $usingTcl ; then
       loader_run_path="${TK_LIB_DIR}:${loader_run_path}"
     fi
   fi
+fi
 
 # -----------------------------------------------------------------------
 #

scripts/configure.in

@@ -807,7 +807,6 @@ dnl "make" instead of requiring "make tcl"
 dnl ----------------------------------------------------------------
 
 if test $usingTcl ; then
-  usingX11=1
   cadinstall="$cadinstall tcltk"
   modules="$modules tcltk"
   programs="$programs tcltk"
@@ -816,7 +815,11 @@ if test $usingTcl ; then
   AC_DEFINE(TCL_NETGEN)
   extra_libs="$extra_libs \${NETGENDIR}/tcltk/libtcltk.o"
   extra_defs="$extra_defs -DTCL_DIR=\\\"\${TCLDIR}\\\""
-  stub_defs="$stub_defs -DUSE_TCL_STUBS -DUSE_TK_STUBS"
+  if test $usingX11 ; then
+    stub_defs="$stub_defs -DUSE_TCL_STUBS"
+  else
+    stub_defs="$stub_defs -DUSE_TCL_STUBS -DUSE_TK_STUBS"
+  fi
 else
   programs="$programs netgen"
   unused="$unused tcltk"
@@ -903,6 +906,7 @@ if test $usingTcl ; then
 # Tk libraries and header files
 #
 # -----------------------------------------------------------------------
+if test $usingX11 ; then
   if test "${TK_INC_DIR}" != "/usr/include" ; then
     INC_SPECS="${INC_SPECS} -I${TK_INC_DIR}"
   fi
@@ -919,6 +923,7 @@ if test $usingTcl ; then
       loader_run_path="${TK_LIB_DIR}:${loader_run_path}"
     fi
   fi
+fi
 
 # -----------------------------------------------------------------------
 #

tcltk/netgen.tcl.in

@@ -479,8 +479,12 @@ proc netgen::lvs { name1 name2 {setupfile setup.tcl} {logfile comp.out} args} {
 
    netgen::compare assign "$fnum1 $cell1" "$fnum2 $cell2"
 
-   if {[file exists $setupfile]} {
-      puts stdout "Reading setup file $setupfile"
+   if {$setupfile == ""} {
+      puts stdout "\nNo setup file specified.  Using trivial default setup.\n"
+      netgen::permute default	;# transistors and resistors
+      netgen::property default
+   } elseif {[file exists $setupfile]} {
+      puts stdout "\nReading setup file $setupfile\n"
       # Instead of sourcing the setup file, run each line so we can
       # catch individual errors and not let them halt the LVS process
       set perrors 0
@@ -508,8 +512,10 @@ proc netgen::lvs { name1 name2 {setupfile setup.tcl} {logfile comp.out} args} {
 	 puts stdout "Warning:  There were errors reading the setup file"
       }
    } elseif {[string first nosetup $setupfile] < 0} {
-      netgen::permute default	;# transistors and resistors
-      netgen::property default
+      puts stderr "\nError:  Setup file $setupfile does not exist.\n"
+      return
+   } else {
+      puts stderr "\nNo setup file specified.  Continuing without a setup.\n"
    }
 
    if {[string first nolog $logfile] < 0} {

tcltk/tclnetgen.c

@@ -2902,7 +2902,7 @@ _netcmp_equate(ClientData clientData,
    struct ElementClass *saveEclass = NULL;
    struct NodeClass *saveNclass = NULL;
    int file1, file2;
-   int i, l1, l2, ltest, lent, dolist = 0, doforce = 0;
+   int i, l1, l2, ltest, lent, dolist = 0, doforce = 0, dounique = 0;
    Tcl_Obj *tobj1, *tobj2, *tobj3;
 
    while (objc > 1) {
@@ -2918,6 +2918,11 @@ _netcmp_equate(ClientData clientData,
 	 objv++;
 	 objc--;
       }
+      else if (!strcmp(optstart, "unique")) {
+	 dounique = 1;
+	 objv++;
+	 objc--;
+      }
       else
 	 break;
    }
@@ -3342,19 +3347,9 @@ _netcmp_equate(ClientData clientData,
 		    return TCL_ERROR;
 		}
 	    }
-
-	    /* Now that all pins are assigned by name, reorder	*/
-	    /* the pin lists of the 2nd cell to match the	*/
-	    /* order of the 1st.				*/
-
-	    /* Reorder the pin lists of instances of the 2nd	*/
-	    /* cell to match the order of the 1st.		*/
-
-	    // pindata.cell2 = tp2;
-	    // RecurseCellHashTable2(pinorder, (void *)(&pindata));
 	 }
 
-	 if (EquivalenceClasses(tp1->name, file1, tp2->name, file2)) {
+	 if (EquivalenceClasses(tp1->name, file1, tp2->name, file2, dounique)) {
 	    Fprintf(stdout, "Device classes %s and %s are equivalent.\n",
 			tp1->name, tp2->name);
 	    Tcl_SetObjResult(interp, Tcl_NewBooleanObj(1));
@@ -3377,6 +3372,8 @@ _netcmp_equate(ClientData clientData,
 /*	add	  --- add new property			*/
 /*	remove	  --- delete existing property		*/
 /*	tolerance --- set property tolerance		*/
+/*	associate --- associate property with a pin	*/
+/*	topology  --- set exact/relaxed matching	*/
 /*	merge	  --- (deprecated)			*/
 /* or							*/
 /*	netgen::property default			*/
@@ -3415,11 +3412,11 @@ _netcmp_property(ClientData clientData,
 
     char *options[] = {
 	"add", "create", "remove", "delete", "tolerance", "merge", "serial",
-	"series", "parallel", NULL
+	"series", "parallel", "associate", "topology", NULL
     };
     enum OptionIdx {
 	ADD_IDX, CREATE_IDX, REMOVE_IDX, DELETE_IDX, TOLERANCE_IDX, MERGE_IDX,
-	SERIAL_IDX, SERIES_IDX, PARALLEL_IDX
+	SERIAL_IDX, SERIES_IDX, PARALLEL_IDX, ASSOCIATE_IDX, TOPOLOGY_IDX
     };
     int result, index, idx2;
 
@@ -3464,6 +3461,10 @@ _netcmp_property(ClientData clientData,
 	return TCL_ERROR;
     }
 
+    char *topo[] = {
+	"strict", "relaxed", NULL
+    };
+
     /* Check for special command "property default" */
     if ((objc == 2) && (!strcmp(Tcl_GetString(objv[1]), "default"))) {
 
@@ -3549,6 +3550,36 @@ _netcmp_property(ClientData clientData,
 	}
 	return TCL_OK;
     }
+    else if ((objc > 1) && (!strcmp(Tcl_GetString(objv[1]), "topology"))) {
+	if (objc == 2) {
+	    if (ExactTopology)
+		Tcl_SetResult(interp, "Strict topology property matching.",
+			NULL);
+	    else
+		Tcl_SetResult(interp, "Relaxed topology property matching.",
+			NULL);
+	}
+	else if (objc == 3) {
+	    if (Tcl_GetIndexFromObj(interp, objv[2],
+			(CONST84 char **)topo,
+			"topology", 0, &idx2) == TCL_OK) {
+		if (idx2 == 0)
+		    ExactTopology = TRUE;
+		else if (idx2 == 1)
+		    ExactTopology = FALSE;
+		else {
+		    Tcl_SetResult(interp, "Topology matching type must be "
+				"'strict' or 'relaxed'.", NULL);
+	    	    return TCL_ERROR;
+		}
+	    }
+	}
+	else {
+	    Tcl_WrongNumArgs(interp, 1, objv, "strict|relaxed");
+	    return TCL_ERROR;
+	}
+	return TCL_OK;
+    }
 
     result = CommonParseCell(interp, objv[1], &tp, &fnum);
     if (result != TCL_OK) return result;
@@ -3842,6 +3873,29 @@ _netcmp_property(ClientData clientData,
 		}
 		break;
 
+	    case ASSOCIATE_IDX:
+		if (objc == 3) {
+		    Tcl_WrongNumArgs(interp, 1, objv, "{property_key pin_name} ...");
+		    return TCL_ERROR;
+		}
+		for (i = 3; i < objc; i++) {
+		    // Each value must be a duplet
+		    result = Tcl_ListObjLength(interp, objv[i], &llen);
+		    if ((result != TCL_OK) || (llen != 2)) {
+			Tcl_SetResult(interp, "Not a {key pin} pair list.",
+					NULL);
+		    }
+		    else {
+			result = Tcl_ListObjIndex(interp, objv[i], 0, &tobj1);
+			if (result != TCL_OK) return result;
+			result = Tcl_ListObjIndex(interp, objv[i], 1, &tobj2);
+			if (result != TCL_OK) return result;
+			PropertyAssociatePin(tp->name, fnum, Tcl_GetString(tobj1),
+					Tcl_GetString(tobj2));
+		    }
+		}
+		break;
+
 	    case TOLERANCE_IDX:
 		if (objc == 3) {
 		    Tcl_WrongNumArgs(interp, 1, objv, "{property_key tolerance} ...");
@@ -3941,6 +3995,7 @@ _netcmp_property(ClientData clientData,
 		    }
 		}
 		break;
+
 	}
     }
     return TCL_OK;