Corrected the parsing for assignment left-hand-side to allow for

whitespace inside the array declaration, as was (correctly) done
for pin connections.  Previously, "assign x[ 0] = 1'b1" would
fail due to "x[" being parsed as a token by itself.  Now, upon
reading an array opening bracket delimiter, the verilog parser
will continue to read tokens until it finds the closing bracket,
as it does for pin connections.

VERSION

@@ -1 +1 @@
-1.5.271
+1.5.323

base/actel.c

@@ -22,6 +22,7 @@ the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
 #include <stdio.h>
 #include <stdarg.h>
+#include <strings.h>
 #include <ctype.h>
 #ifdef IBMPC
 #include <stdlib.h>  /* for strtol on PC */
@@ -90,7 +91,7 @@ char	*ActelName(char *Name)
   /* strip physical-pin information, if it exists */
   if ((nm = strrchr(name,PHYSICALPIN[0])) != NULL) *nm = '\0';
   if (strlen(name) > 13) {
-    ActelIndex = (++ActelIndex) % ACTELNAMESIZE;
+    ActelIndex = (ActelIndex + 1) % ACTELNAMESIZE;
     /* format the value of the hashed value of the string */
     sprintf(ActelNames[ActelIndex], "$%lX", ActelNameHash(name));
 if (Debug) 
@@ -101,7 +102,7 @@ Printf("ActelNameHash returns %s on name %s\n",ActelNames[ActelIndex], name);
   NeedsQuoting = 0;
   if (NULL != strpbrk(name, ".,:; \t\"'\n\r")) NeedsQuoting = 1;
 
-  ActelIndex = (++ActelIndex) % ACTELNAMESIZE;
+  ActelIndex = (ActelIndex + 1) % ACTELNAMESIZE;
   if (!NeedsQuoting) {
     strcpy(ActelNames[ActelIndex], name);
     return(ActelNames[ActelIndex]);

base/flatten.c

@@ -300,8 +300,6 @@ int flattenInstancesOf(char *name, int fnum, char *instance)
       return 0;
     }
   }
-  /* Placeholder cells must not be flattened */
-  if (ThisCell->flags & CELL_PLACEHOLDER) return 0;
 
   FreeNodeNames(ThisCell);
 
@@ -339,6 +337,10 @@ int flattenInstancesOf(char *name, int fnum, char *instance)
 	   LastObj = ParentParams;
 	   continue;
       }
+      if (ChildCell->flags & CELL_PLACEHOLDER) {
+	   LastObj = ParentParams;
+	   continue;	// Placeholder cells must not be flattened
+      }
       if (ChildCell == ThisCell) {
 	   LastObj = ParentParams;
 	   continue;	// Avoid infinite loop
@@ -600,8 +602,10 @@ int flattenInstancesOf(char *name, int fnum, char *instance)
          else break;
 
          /* Put the child cell at the start of ChildObjList */
-         ChildEnd->next = ChildObjList;
+	 if (ChildEnd) {
-         ChildObjList = ChildStart;
+            ChildEnd->next = ChildObjList;
+            ChildObjList = ChildStart;
+	 }
       }
 
       /* Put the child cell at the start of ChildObjList */
@@ -1304,6 +1308,14 @@ int UniquePins(char *name, int filenum)
    return 1;
 }
 
+/* Structure used below for keeping track of node numbers
+ * belonging to removed nodes.
+ */
+struct LinkedNum {
+    int node;
+    struct LinkedNum *next;
+};
+
 /*------------------------------------------------------*/
 /* Callback function for CleanupPins			*/
 /* Note that if the first pin of the instance is a	*/
@@ -1316,6 +1328,7 @@ struct nlist *cleanuppins(struct hashlist *p, void *clientdata)
    struct nlist *ptr;
    struct objlist *ob, *obt, *lob, *nob, *firstpin, *pob;
    struct nlist *tc = (struct nlist *)clientdata;
+   struct LinkedNum *newnodenum, *removedNodes = (struct LinkedNum *)NULL;
    int pinnum;
    char *saveinst = NULL;
 
@@ -1371,6 +1384,15 @@ struct nlist *cleanuppins(struct hashlist *p, void *clientdata)
 		    saveinst = ob->instance.name;
 		}
 		if (ob->model.class != NULL) FREE(ob->model.class);
+
+		// Record the net number of the pin being removed, to
+		// check at the end if the net belonged to a pin that
+		// got orphaned.
+		newnodenum = (struct LinkedNum *)MALLOC(sizeof(struct LinkedNum));
+		newnodenum->node = ob->node;
+		newnodenum->next = removedNodes;
+		removedNodes = newnodenum;
+
 		FREE(ob);
 	     }
 	     else {
@@ -1414,6 +1436,28 @@ struct nlist *cleanuppins(struct hashlist *p, void *clientdata)
       }
    }
 
+   while (removedNodes != NULL) {
+	int nodenum = removedNodes->node;
+	struct objlist *ob2;
+
+	/* Only concerned with nodes that are in the pin list of ptr->cell */
+	for (ob = ptr->cell; ob != NULL; ob = ob->next) {
+	    if (ob->type != PORT) break;
+	    if (ob->node == nodenum) break;
+	}
+	if (ob && (ob->type == PORT)) {
+	    /* Check if this node number exists only in the port record */
+	    for (nob = ob->next; nob != NULL; nob = nob->next)
+		if (nob->node == nodenum) break;
+	    if (nob == NULL) {
+		ob->node = -1;		/* This pin is now disconnected */
+	    }
+	}
+	newnodenum = removedNodes;
+	removedNodes = removedNodes->next;
+	FREE(newnodenum);
+   }
+
    if (saveinst != NULL) FREE(saveinst);
    return NULL;		/* Keep the search going */
 }
@@ -1634,7 +1678,7 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
     ECompare *ecomp, *ncomp;
     ECompList *list0X, *listX0;
     int hascontents1, hascontents2;
-    int match, modified = 0;
+    int match, modified1 = 0, modified2 = 0;
     int not_top;
 
     if (file1 == -1)
@@ -1711,16 +1755,26 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 		    Fprintf(stdout, "Flattening instances of %s in cell %s (%d)"
 				" makes a better match\n", ecomp->cell1->name,
 				name1, file1);
-		    flattenInstancesOf(name1, file1, ecomp->cell1->name); 
+		    if (flattenInstancesOf(name1, file1, ecomp->cell1->name) > 0)
-		    modified++;
+			modified1++;
+		}
+		else if (ecomp->cell1 && (ecomp->num1 > 0)) {
+		    Fprintf(stdout, "Flattening instances of %s in cell %s (%d)"
+				" would make a better match but is prohibited.\n",
+				ecomp->cell1->name, name1, file1);
 		}
 		if (ecomp->cell2 && (ecomp->num2 > 0) &&
 				(!(ecomp->cell2->flags & CELL_PLACEHOLDER))) {
 		    Fprintf(stdout, "Flattening instances of %s in cell %s (%d)"
 				" makes a better match\n", ecomp->cell2->name,
 				name2, file2);
-		    flattenInstancesOf(name2, file2, ecomp->cell2->name); 
+		    if (flattenInstancesOf(name2, file2, ecomp->cell2->name) > 0)
-		    modified++;
+			modified2++;
+		}
+		else if (ecomp->cell2 && (ecomp->num2 > 0)) {
+		    Fprintf(stdout, "Flattening instances of %s in cell %s (%d)"
+				" would make a better match but is prohibited.\n",
+				ecomp->cell2->name, name2, file2);
 		}
 	    }
 
@@ -1809,8 +1863,13 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 		    	Fprintf(stdout, "Flattening instances of %s in cell %s (%d)"
 				" makes a better match\n", ecomp->cell2->name,
 				name2, file2);
-		    	flattenInstancesOf(name2, file2, ecomp->cell2->name); 
+		    	if (flattenInstancesOf(name2, file2, ecomp->cell2->name) > 0)
-		    	modified++;
+			    modified2++;
+		    }
+		    else if (ecomp->cell2) {
+			Fprintf(stdout, "Flattening instances of %s in cell %s (%d)"
+				" would make a better match but is prohibited.\n",
+				ecomp->cell2->name, name2, file2);
 		    }
 		}
 	    }
@@ -1875,8 +1934,13 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 		    	Fprintf(stdout, "Flattening instances of %s in cell %s (%d)"
 				" makes a better match\n", ecomp->cell1->name,
 				name1, file1);
-		    	flattenInstancesOf(name1, file1, ecomp->cell1->name); 
+		    	if (flattenInstancesOf(name1, file1, ecomp->cell1->name) > 0)
-		        modified++;
+			    modified1++;
+		    }
+		    else if (ecomp->cell1) {
+			Fprintf(stdout, "Flattening instances of %s in cell %s (%d)"
+				" would make a better match but is prohibited.\n",
+				ecomp->cell1->name, name1, file1);
 		    }
 		}
 	    }
@@ -1954,8 +2018,11 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 						    break;
 					    }
 					}
+					if (found) break;
+				    }
 
-					/* Do NOT remove shorting devices that	*/
+				    if (found) {
+					/* Beware remove shorting devices that	*/
 					/* connect two ports.  Otherwise the	*/
 					/* port lists get screwed up.  It is	*/
 					/* better in that case to force the	*/
@@ -1963,6 +2030,10 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 					/* This is ignored for a top-level cell	*/
 					/* because it will just show up as a	*/
 					/* port mismatch error as it should.	*/
+					/* (12/12/2025---disabling this worked;	*/
+					/* may need to go back to a failing	*/
+					/* example and determine how pin	*/
+					/* matching gets scrambled.)		*/
 
 					if ((not_top == TRUE) &&
 						(ecomp->cell1->class != CLASS_ISOURCE)) {
@@ -1975,14 +2046,18 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 						else if (ob2->node == node2)
 						    found2 = TRUE;
 						if (found1 && found2) {
-						    found = FALSE;
+						    Fprintf(stdout, "Warning: "
+							"zero-valued device connects "
+							"port %s to another port;  pin "
+							"matching may be affected.\n",
+							ob2->name);
+						    // found = FALSE;
 						    break;
 						}
 					    }
 					}
-
-					if (found) break;
 				    }
+
 				    if (found) {
 					Fprintf(stdout, "Removing zero-valued device "
 						"%s from cell %s (%d) makes a better "
@@ -2030,7 +2105,7 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 
 					/* Remove from list */
 					ecomp->num1--;
-					modified++;
+					modified1++;
 
 					ob1 = lob;
 				    }
@@ -2168,8 +2243,8 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 					}
 
 					/* Remove from list */
-					ecomp->num1--;
+					ecomp->num2--;
-					modified++;
+					modified2++;
 
 					ob2 = lob;
 				    }
@@ -2203,7 +2278,7 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
     // are no other modifications, as this rule is relaxed compared to other
     // rules, and the other rules should be exhaustively applied first.
 
-    if ((listX0 != NULL) && (list0X != NULL) && (modified == 0)) {
+    if ((listX0 != NULL) && (list0X != NULL) && ((modified1 + modified2) == 0)) {
 	ECompare *ecomp0X, *ecompX0;
 	ECompList *elist0X, *elistX0;
 	for (elistX0 = listX0; elistX0; elistX0 = elistX0->next) {
@@ -2229,13 +2304,24 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 					ecompX0->cell1->file, &compdict);
 			    if (dstr) *dstr = '[';
 			    if ((ncomp == ecomp0X) && (ecomp0X->num2 <= ecompX0->num1)) {
-				Fprintf(stdout, "Flattening instances of %s in cell %s"
+				if (!(ecompX0->cell1->flags & CELL_PLACEHOLDER)) {
-					"(%d) makes a better match\n",
+				    Fprintf(stdout, "Flattening instances of %s in cell"
-					ecompX0->cell1->name, name1, file1);
+						" %s (%d) makes a better match\n",
-				flattenInstancesOf(name1, file1, ecompX0->cell1->name); 
+						ecompX0->cell1->name, name1, file1);
-			        ecompX0->num1 = 0;
+				    if (flattenInstancesOf(name1, file1,
-			        ecomp0X->num1 += ecompX0->num1;
+						ecompX0->cell1->name) > 0) {
-				modified++;
+					ecompX0->num1 = 0;
+					ecomp0X->num1 += ecompX0->num1;
+					modified1++;
+				    }
+				}
+				else
+				{
+				    Fprintf(stdout, "Flattening instances of %s in "
+						"cell %s (%d) would make a better "
+						"match but is prohibited.\n",
+						ecompX0->cell1->name, name1, file1);
+				}
 				break;
 			    }
 			}
@@ -2255,13 +2341,23 @@ PrematchLists(char *name1, int file1, char *name2, int file2)
 					ecomp0X->cell2->file, &compdict);
 			    if (dstr) *dstr = '[';
 			    if ((ncomp == ecompX0) && (ecompX0->num1 <= ecomp0X->num2)) {
-				Fprintf(stdout, "Flattening instances of %s in cell %s"
+				if (!(ecomp0X->cell2->flags & CELL_PLACEHOLDER)) {
-					" (%d) makes a better match\n",
+				    Fprintf(stdout, "Flattening instances of %s in cell"
-					ecomp0X->cell2->name, name2, file2);
+						" %s (%d) makes a better match\n",
-				flattenInstancesOf(name2, file2, ecomp0X->cell2->name); 
+						ecomp0X->cell2->name, name2, file2);
-			        ecomp0X->num2 = 0;
+				    if (flattenInstancesOf(name2, file2,
-			        ecompX0->num2 += ecomp0X->num2;
+						ecomp0X->cell2->name) > 0) {
-				modified++;
+					ecomp0X->num2 = 0;
+					ecompX0->num2 += ecomp0X->num2;
+					modified2++;
+				    }
+				}
+				else {
+				    Fprintf(stdout, "Flattening instances of %s in "
+						"cell %s (%d) would make a better "
+						"match but is prohibited.\n",
+						ecompX0->cell2->name, name2, file2);
+				}
 				break;
 			    }
 			}
@@ -2292,5 +2388,17 @@ done:
 	FREE(list0X);
 	list0X = nextptr;
     }
-    return modified;
+
+    // If either netlist was modified, rebuild its node cache
+
+    if (modified1 > 0) {
+	FreeNodeNames(tc1);
+	CacheNodeNames(tc1);
+    }
+    if (modified2 > 0) {
+	FreeNodeNames(tc2);
+	CacheNodeNames(tc2);
+    }
+
+    return modified1 + modified2;
 }

base/hash.c

@@ -137,32 +137,39 @@ static unsigned char uppercase[] = {
 // horrible things can happen, as, for example, names AOI12 and OAI12
 // have exactly the same hash result.  Lousy for binning and even
 // lousier for generating class magic numbers.
+//
+// Updated again 4/2/2026 to the FNV-1a hash, which is better than
+// SDBM for this application, according to ChatGPT.
 
 unsigned long hashnocase(char *s, int hashsize)
 {
-	unsigned long hashval;
+	unsigned long hashval = 2166136261ul;
-	
+	for (; *s != '\0'; s++) {
-	for (hashval = 0; *s != '\0'; )
+	    hashval ^= uppercase[*s];
-	    hashval = uppercase[*s++]
+	    hashval *= 16777619ul;
-			+ (hashval << 6) + (hashval << 16) - hashval;
+	}
 	return (hashsize == 0) ? hashval : (hashval % hashsize);
 }
 
 unsigned long hashcase(char *s, int hashsize)
 {
-	unsigned long hashval;
+	unsigned long hashval = 2166136261ul;
-	
+	for (; *s != '\0'; s++) {
-	for (hashval = 0; *s != '\0'; )
+	    hashval ^= (unsigned char)(*s);
-	    hashval = (*s++) + (hashval << 6) + (hashval << 16) - hashval;
+	    hashval *= 16777619ul;
+	}
 	return (hashsize == 0) ? hashval : (hashval % hashsize);
 }
 
 unsigned long genhash(char *s, int c, int hashsize)
 {
-	unsigned long hashval;
+	unsigned long hashval = 2166136261ul;
-	
+	hashval ^= (unsigned long)c;
-	for (hashval = (unsigned long)c; *s != '\0'; )
+	hashval *= 16777619ul;
-	    hashval = (*s++) + (hashval << 6) + (hashval << 16) - hashval;
+	for (; *s != '\0'; s++) {
+	    hashval ^= (unsigned char)(*s);
+	    hashval *= 16777619ul;
+	}
 	return (hashsize == 0) ? hashval : (hashval % hashsize);
 }
 

base/netcmp.h

@@ -62,7 +62,7 @@ extern void RegroupDataStructures();
 extern void FormatIllegalElementClasses();
 extern void FormatIllegalNodeClasses();
 extern int ResolveAutomorphsByProperty();
-extern int ResolveAutomorphsByPin();
+extern int ResolveAutomorphsByPin(int match_nets);
 extern void SummarizeElementClasses(struct ElementClass *EC);
 extern int remove_group_tags(struct objlist *ob);
 
@@ -70,6 +70,8 @@ extern int remove_group_tags(struct objlist *ob);
 #ifdef TCL_NETGEN
 extern int EquivalentNode();
 extern int EquivalentElement();
+extern void DeriveAreaProperty();
+extern void DerivePerimeterProperty();
 
 extern void enable_interrupt();
 extern void disable_interrupt();

base/netfile.c

@@ -302,7 +302,7 @@ int GetNextLineNoNewline(char *delimiter)
 {
     char *newbuf;
     int testc;
-    int nested = 0;
+    static int nested = 0;
     int llen;
 
     if (feof(infile)) return -1;
@@ -329,6 +329,11 @@ int GetNextLineNoNewline(char *delimiter)
 	    llen = strlen(line);
 	}
 	while (llen == linesize - 1) {
+	    /* Note that in the rare case where a newline is in the last buffer
+	     * position, we're done.
+	     */
+	    if (*(line + llen - 1) == '\n') break;
+
 	    newbuf = (char *)MALLOC(linesize + 501);
 	    strcpy(newbuf, line);
 	    FREE(line);
@@ -599,7 +604,7 @@ void SpiceTokNoNewline(void)
 {
     int contline;
 
-    if ((nexttok = strdtok(NULL, WHITESPACE_DELIMITER, NULL)) != NULL) return;
+    if ((nexttok = strdtok0(NULL, WHITESPACE_DELIMITER, NULL, FALSE)) != NULL) return;
 
     while (nexttok == NULL) {
 	contline = getc(infile);
@@ -680,6 +685,7 @@ void SpiceSkipNewLine(void)
   ungetc(contline, infile);
 }
 
+#if 0 /* Commented with "#if 0" due to comment characters in the comment */
 /*----------------------------------------------------------------------*/
 /* Function similar to strtok() for token parsing.  The difference is	*/
 /* that it takes two sets of delimiters.  The first is whitespace	*/
@@ -700,8 +706,9 @@ void SpiceSkipNewLine(void)
 /* the first character of the delimiter string in addition to marking	*/
 /* the boundary between two-character and one-character delimiters.	*/
 /*----------------------------------------------------------------------*/
+#endif
 
-char *strdtok(char *pstring, char *delim1, char *delim2)
+char *strdtok0(char *pstring, char *delim1, char *delim2, char isverilog)
 {
     static char *stoken = NULL;
     static char *sstring = NULL;
@@ -746,7 +753,7 @@ char *strdtok(char *pstring, char *delim1, char *delim2)
     /* should know whether it is parsing SPICE or verilog and handle the syntax	*/
     /* accordingly (needs to be done).						*/
 
-    if (*s == '\\') {
+    if (isverilog && (*s == '\\')) {
         s++;
         while (*s != '\0') {
 	    if ((*s == ' ') || ((*s == '\\') && (*(s + 1) == '\0'))) {
@@ -817,6 +824,17 @@ char *strdtok(char *pstring, char *delim1, char *delim2)
     return sstring;
 }
 
+/*----------------------------------------------------------------------*/
+/* strdtok() is the original string tokenizer.  It calls strdtok0()	*/
+/* with isverilog=TRUE, so that tokens are parsed as (potentially)	*/
+/* verilog names, which includes verilog backslash notation.		*/
+/*----------------------------------------------------------------------*/
+
+char *strdtok(char *pstring, char *delim1, char *delim2)
+{
+   return strdtok0(pstring, delim1, delim2, TRUE);
+}
+
 /*----------------------------------------------------------------------*/
 
 void InputParseError(FILE *f)

base/netfile.h

@@ -36,6 +36,7 @@ extern struct hashdict *definitions;
 
 extern char *nexttok;
 #define SKIPTO(a) do {SkipTok(NULL);} while (!match(nexttok,a))
+extern char *strdtok0(char *pstring, char *delim1, char *delim2, char isverilog);
 extern char *strdtok(char *pstring, char *delim1, char *delim2);
 extern char *GetLineAtTok();
 extern void SkipTok(char *delimiter);

base/netgen.c

@@ -25,6 +25,8 @@ the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 #include <stdio.h>
 #include <stdlib.h>	/* for strtof() */
 #include <stdarg.h>
+#include <string.h>
+#include <strings.h>
 #include <ctype.h>	/* toupper() */
 #ifdef IBMPC
 #include <alloc.h>
@@ -2248,7 +2250,10 @@ int PromoteProperty(struct property *prop, struct valuelist *vl,
     if (prop == NULL || vl == NULL) return -1;
     if (prop->type == vl->type) return 1;	/* Nothing to do */
     result = 0;
-    if (prop->type == PROP_EXPRESSION) {
+    /* If vl is an expression but prop is not, then try to reduce
+     * the expression in vl.
+     */
+    if (vl->type == PROP_EXPRESSION) {
 	ReduceOneExpression(vl, ob, tc, FALSE);
     }
     switch (prop->type) {
@@ -3094,7 +3099,7 @@ void add_balancing_close(struct objlist *ob1, struct objlist *ob2)
    for (nob = ob1->next; nob && nob->type != FIRSTPIN; nob = nob->next)
       if (nob->type == PROPERTY)
 	 break;
-   if (nob->type != PROPERTY) return;	// shouldn't happen
+   if (nob == NULL || nob->type != PROPERTY) return;	// shouldn't happen
 
    opentags = 0;
    for (; nob->next && nob->next->type == PROPERTY; nob = nob->next) {
@@ -3644,7 +3649,7 @@ int CombineSeries(char *model, int file)
 	       nob->type = PROPERTY;
 	       nob->name = strsave("properties");
 	       nob->node = -2;	/* Don't report as disconnected node */
-	       nob->model.class = (obp->model.class == NULL) ? NULL :
+	       nob->model.class = (obp == NULL || obp->model.class == NULL) ? NULL :
 				strsave(obp->model.class);
 	       nob->instance.props = NewPropValue(2);
 

base/objlist.c

@@ -223,12 +223,35 @@ int matchnocase(char *st1, char *st2)
 {
    char *sp1 = st1;
    char *sp2 = st2;
+   char v1 = FALSE, v2 = FALSE;
+
+   /* In case of a property that does not exist in one netlist, matchnocase()
+    * may be passed a null value, so return 0 to indicate a non-match.
+    * *Both* values null will also be treated as a mismatch (debatable
+    * behavior).
+    */
+   if (!sp1 || !sp2) return 0;
+
+   /* Verilog back-slash escaped names should match an equivalent non-
+    * back-slashed name.  (NOTE: This behavior needs to be added to match().)
+    */
+   if ((*sp1 == '\\') && (*sp2 != '\\')) {
+      v1 = TRUE;
+      sp1++;
+   }
+   if ((*sp2 == '\\') && (*sp1 != '\\')) {
+      v2 = TRUE;
+      sp2++;
+   }
 
    while (*sp1 != '\0' && *sp2 != '\0') {
       if (to_lower[*sp1] != to_lower[*sp2]) break;
       sp1++;
       sp2++;
    }
+   if (v1 && (*sp1 == ' ')) sp1++;
+   if (v2 && (*sp2 == ' ')) sp2++;
+
    if ((*sp1 != '\0') || (*sp2 != '\0')) return 0;
    return 1;
 }
@@ -259,6 +282,33 @@ int matchfilenocase(char *st1, char *st2, int f1, int f2)
    return 1;
 }
 
+/* Delimiter matching---Find an opening delimiter in a string.		*/
+/* Return the position of the first opening delimeter in the string,	*/
+/* like strchr().  Place the actual delimeter character in *delim.	*/
+
+char *get_array_delimiter(char *name, char *delim)
+{
+    char *stest = name;
+
+    while (*stest != '\0')
+    {
+	if (to_lower[*stest] == '<') {
+	    *delim = *stest;
+	    return stest;
+	}
+	stest++;
+    }
+    return NULL;
+}
+
+/* Delimiter parsing---Check if a character is an opening array delimiter. */
+/* Return TRUE if the character is an opening delimiter, FALSE if not.	   */
+
+int is_delimiter(char testc)
+{
+    return (to_lower[testc] == '<') ? TRUE : FALSE;
+}
+
 #ifdef HAVE_MALLINFO
 void PrintMemoryStats(void)
 {
@@ -426,6 +476,7 @@ int removeshorted(struct hashlist *p, int file)
          ob = nob;
       }
    }
+   return 1;
 }
 
 /* Remove shorted instances of class "class" from the database */
@@ -516,6 +567,7 @@ int deleteclass(struct hashlist *p, int file)
       }
    }
    FREE(checknodes);
+   return 1;
 }
 
 /* Remove all instances of class "class" from the database */
@@ -553,6 +605,7 @@ int renameinstances(struct hashlist *p, int file)
 	 }
       }
    }
+   return 1;
 }
 
 void InstanceRename(char *from, char *to, int file)
@@ -575,9 +628,10 @@ int freeprop(struct hashlist *p)
    struct property *prop;
 
    prop = (struct property *)(p->ptr);
-   if (prop->type == PROP_STRING)
+   if (prop->type == PROP_STRING) {
       if (prop->pdefault.string != NULL)
 	 FREE(prop->pdefault.string);
+   }
    else if (prop->type == PROP_EXPRESSION) {
       struct tokstack *stackptr, *nptr;
       stackptr = prop->pdefault.stack;
@@ -596,65 +650,65 @@ int freeprop(struct hashlist *p)
 
 void CellDelete(char *name, int fnum)
 {
-  /* delete all the contents of cell 'name', and remove 'name' from
+   /* delete all the contents of cell 'name', and remove 'name' from
-     the cell hash table.  NOTE:  this procedure does not care or check
+      the cell hash table.  NOTE:  this procedure does not care or check
-     if 'name' has been instanced anywhere.  It is assumed that if this
+      if 'name' has been instanced anywhere.  It is assumed that if this
-     is the case, the user will (quickly) define a new cell of that name.
+      is the case, the user will (quickly) define a new cell of that name.
-  */
+   */
-  struct objlist *ob, *obnext;
+   struct objlist *ob, *obnext;
-  struct nlist *tp;
+   struct nlist *tp;
 
-  tp = LookupCellFile(name, fnum);
+   tp = LookupCellFile(name, fnum);
-  if (tp == NULL) {
+   if (tp == NULL) {
-    Printf ("No cell '%s' found.\n", name);
+      Printf ("No cell '%s' found.\n", name);
-    return;
+      return;
-  }
+   }
 
-  HashIntDelete(name, fnum, &cell_dict);
+   HashIntDelete(name, fnum, &cell_dict);
-  /* now make sure that we free all the fields of the nlist struct */
+   /* now make sure that we free all the fields of the nlist struct */
-  if (tp->name != NULL) FREE(tp->name);
+   if (tp->name != NULL) FREE(tp->name);
-  HashKill(&(tp->objdict));
+   HashKill(&(tp->objdict));
-  HashKill(&(tp->instdict));
+   HashKill(&(tp->instdict));
-  RecurseHashTable(&(tp->propdict), freeprop);
+   RecurseHashTable(&(tp->propdict), freeprop);
-  HashKill(&(tp->propdict));
+   HashKill(&(tp->propdict));
-  FreeNodeNames(tp);
+   FreeNodeNames(tp);
-  ob = tp->cell;
+   ob = tp->cell;
-  while (ob != NULL) {
+   while (ob != NULL) {
-    obnext = ob->next;
+      obnext = ob->next;
-    FreeObject (ob);
+      FreeObject (ob);
-    ob = obnext;
+      ob = obnext;
-  }
+   }
 }
 
 static int PrintCellHashTableElement(struct hashlist *p)
 {
-  struct nlist *ptr;
+   struct nlist *ptr;
 
-  ptr = (struct nlist *)(p->ptr);
+   ptr = (struct nlist *)(p->ptr);
-  if ((TopFile >= 0) && (ptr->file != TopFile)) return 1;
+   if ((TopFile >= 0) && (ptr->file != TopFile)) return 1;
 
-  if (ptr->class != CLASS_SUBCKT) {
+   if ((ptr->class != CLASS_SUBCKT) && (ptr->class != CLASS_MODULE)) {
-    /* only print primitive cells if Debug is enabled */
+      /* only print primitive cells if Debug is enabled */
-    if (Debug == 1)  Printf("Cell: %s (instanced %d times); Primitive\n",
+      if (Debug == 1)  Printf("Cell: %s (instanced %d times); Primitive\n",
 		       ptr->name, ptr->number);
-    else if (Debug == 3) {	/* list */
+      else if (Debug == 3) {	/* list */
 #ifdef TCL_NETGEN
-       Tcl_AppendElement(netgeninterp, ptr->name);
+          Tcl_AppendElement(netgeninterp, ptr->name);
 #else
-       Printf("%s ", ptr->name);
+          Printf("%s ", ptr->name);
 #endif
-    }
+      }
-  }
+   }
-  else if ((Debug == 2) || (Debug == 3)) {	/* list only */
+   else if ((Debug == 2) || (Debug == 3)) {	/* list only */
 #ifdef TCL_NETGEN
-     Tcl_AppendElement(netgeninterp, ptr->name);
+      Tcl_AppendElement(netgeninterp, ptr->name);
 #else
-     Printf("%s ", ptr->name);
+      Printf("%s ", ptr->name);
 #endif
-  }
+   }
-  else
+   else
-    Printf("Cell: %s (instanced %d times)\n",ptr->name,ptr->number);
+      Printf("Cell: %s (instanced %d times)\n", ptr->name, ptr->number);
-  return(1);
+   return(1);
 }
 
 /* Print the contents of the cell hash table.	*/
@@ -663,65 +717,65 @@ static int PrintCellHashTableElement(struct hashlist *p)
 
 void PrintCellHashTable(int full, int filenum)
 {
-  int total, bins;
+   int total, bins;
-  int OldDebug;
+   int OldDebug;
 
-  if ((filenum == -1) && (Circuit1 != NULL) && (Circuit2 != NULL)) {
+   if ((filenum == -1) && (Circuit1 != NULL) && (Circuit2 != NULL)) {
       PrintCellHashTable(full, Circuit1->file);
       PrintCellHashTable(full, Circuit2->file);
       return;
-  }
+   }
 
-  TopFile = filenum;
+   TopFile = filenum;
 
-  bins  = RecurseHashTable(&cell_dict, CountHashTableBinsUsed);
+   bins  = RecurseHashTable(&cell_dict, CountHashTableBinsUsed);
-  total = RecurseHashTable(&cell_dict, CountHashTableEntries);
+   total = RecurseHashTable(&cell_dict, CountHashTableEntries);
-  if (full < 2)
+   if (full < 2)
-     Printf("Hash table: %d of %d bins used; %d cells total (%.2f per bin)\n",
+       Printf("Hash table: %d of %d bins used; %d cells total (%.2f per bin)\n",
 		bins, CELLHASHSIZE, total, (bins == 0) ? 0 :
 		(float)((float)total / (float)bins));
 	
-  OldDebug = Debug;
+   OldDebug = Debug;
-  Debug = full;
+   Debug = full;
-  RecurseHashTable(&cell_dict, PrintCellHashTableElement);
+   RecurseHashTable(&cell_dict, PrintCellHashTableElement);
-  Debug = OldDebug;
+   Debug = OldDebug;
 #ifndef TCL_NETGEN
-  if (full >= 2) Printf("\n");
+   if (full >= 2) Printf("\n");
 #endif
 }
 
 struct nlist *FirstCell(void)
 {
-  return((struct nlist *)HashFirst(&cell_dict));
+   return((struct nlist *)HashFirst(&cell_dict));
 }
 
 struct nlist *NextCell(void)
 {
-  return((struct nlist *)HashNext(&cell_dict));
+   return((struct nlist *)HashNext(&cell_dict));
 }
 
 static int ClearDumpedElement(struct hashlist *np)
 {
-	struct nlist *p;
+   struct nlist *p;
 
-	p = (struct nlist *)(np->ptr);
+   p = (struct nlist *)(np->ptr);
-	p->dumped = 0;
+   p->dumped = 0;
-	return(1);
+   return(1);
 }
 
 void ClearDumpedList(void)
 {
-	RecurseHashTable(&cell_dict, ClearDumpedElement);
+   RecurseHashTable(&cell_dict, ClearDumpedElement);
 }
 
 int RecurseCellHashTable(int (*foo)(struct hashlist *np))
 {
-  return RecurseHashTable(&cell_dict, foo);
+   return RecurseHashTable(&cell_dict, foo);
 }
 
 int RecurseCellFileHashTable(int (*foo)(struct hashlist *, int), int value)
 {
-  return RecurseHashTableValue(&cell_dict, foo, value);
+   return RecurseHashTableValue(&cell_dict, foo, value);
 }
 
 /* Yet another version, passing one parameter that is a pointer */
@@ -729,7 +783,7 @@ int RecurseCellFileHashTable(int (*foo)(struct hashlist *, int), int value)
 struct nlist *RecurseCellHashTable2(struct nlist *(*foo)(struct hashlist *,
 	void *), void *pointer)
 {
-  return RecurseHashTablePointer(&cell_dict, foo, pointer);
+   return RecurseHashTablePointer(&cell_dict, foo, pointer);
 }
 
 /************************** WILD-CARD STUFF *******************************/

base/objlist.h

@@ -309,6 +309,8 @@ extern int  match(char *, char *);
 extern int  matchnocase(char *, char *);
 extern int  matchfile(char *, char *, int, int);
 extern int  matchfilenocase(char *, char *, int, int);
+extern int  is_delimiter(char);
+extern char *get_array_delimiter(char *, char *);
 
 extern void GarbageCollect(void);
 extern void InitGarbageCollection(void);

base/query.c

@@ -319,7 +319,7 @@ void Fanout(char *cell, char *node, int filter)
     while (ob != NULL) {
       char *obname = ob->name;
       if (*obname == '/') obname++;
-      if (ob->node == nodenum)
+      if (ob->node == nodenum) {
 	 if (filter == ALLOBJECTS) {
 	   Printf("  %s (", obname);
 	   PrintObjectType(ob->type);
@@ -331,6 +331,7 @@ void Fanout(char *cell, char *node, int filter)
 	 else if (ob->type == filter) {
 	   Printf("  %s\n", obname);
 	 }
+      }
       ob = ob->next;
     }
   }
@@ -933,7 +934,7 @@ static int PrintLeavesInCellHash(struct hashlist *p)
   struct nlist *ptr;
 
   ptr = (struct nlist *)(p->ptr);
-  if ((ptr->class == CLASS_SUBCKT)) PrintLeavesInCell(ptr->name, ptr->file);
+  if (ptr->class == CLASS_SUBCKT) PrintLeavesInCell(ptr->name, ptr->file);
   return(0);
 }
 

base/spice.c

@@ -21,6 +21,9 @@ the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 #include "config.h"
 
 #include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <ctype.h>
 #if 0
 #include <stdarg.h>  /* what about varargs, like in pdutils.c ??? */
 #endif
@@ -193,7 +196,7 @@ void SpiceSubCell(struct nlist *tp, int IsSubCell)
 		 if (ob->type == PROPERTY) {
 		    struct valuelist *vl;
 		    int i;
-		    for (i == 0;; i++) {
+		    for (i = 0;; i++) {
 		       vl = &(ob->instance.props[i]);
 		       if (vl->type == PROP_ENDLIST) break;
 		       else if (vl->type == PROP_VALUE) {
@@ -213,7 +216,7 @@ void SpiceSubCell(struct nlist *tp, int IsSubCell)
 		 if (ob->type == PROPERTY) {
 		    struct valuelist *vl;
 		    int i;
-		    for (i == 0;; i++) {
+		    for (i = 0;; i++) {
 		       vl = &(ob->instance.props[i]);
 		       if (vl->type == PROP_ENDLIST) break;
 		       else if (vl->type == PROP_VALUE) {
@@ -233,7 +236,7 @@ void SpiceSubCell(struct nlist *tp, int IsSubCell)
 	      if (ob->type == PROPERTY) {
 		 struct valuelist *vl;
 		 int i;
-		 for (i == 0;; i++) {
+		 for (i = 0;; i++) {
 		    vl = &(ob->instance.props[i]);
 		    if (vl->type == PROP_ENDLIST) break;
 		    else if (vl->type == PROP_VALUE) {
@@ -396,7 +399,7 @@ int renamepins(struct hashlist *p, int file)
    ptr = (struct nlist *)(p->ptr);
 
    if (ptr->file != file)
-      return 1;
+      return 0;
 
    for (ob = ptr->cell; ob != NULL; ob = ob->next) {
       if (ob->type == FIRSTPIN) {
@@ -423,6 +426,7 @@ int renamepins(struct hashlist *p, int file)
 	 }
       }
    }
+   return 1;
 }
 
 /* If any pins are marked unconnected, see if there are	*/
@@ -532,8 +536,14 @@ void ReadSpiceFile(char *fname, int filenum, struct cellstack **CellStackPtr,
 
     SkipTok(NULL); /* get the next token */
     if ((EndParseFile()) && (nexttok == NULL)) break;
+    if (nexttok == NULL) break;
 
-    if (nexttok[0] == '*') SkipNewLine(NULL);
+    /* Handle comment lines.  Note that some variants of CDL format
+     * use "*." for information that is transparent to SPICE simulators.
+     * Handle "*.GLOBAL" entries.  All others are ignored.
+     */
+    if ((nexttok[0] == '*') && (!matchnocase(nexttok, "*.GLOBAL")))
+	SkipNewLine(NULL);
 
     else if (matchnocase(nexttok, ".SUBCKT")) {
       SpiceTokNoNewline();
@@ -821,7 +831,10 @@ skip_ends:
 
     // Handle some commonly-used cards
 
-    else if (matchnocase(nexttok, ".GLOBAL")) {
+    /* .GLOBAL and *.GLOBAL.  Note that *.GLOBAL is excepted from comment-line
+     * handling, above, so any line starting with '*' is "*.GLOBAL".
+     */
+    else if (matchnocase(nexttok, ".GLOBAL") || (nexttok[0] == '*')) {
       while (nexttok != NULL) {
 	 int numnodes = 0;
          SpiceTokNoNewline();
@@ -1770,10 +1783,19 @@ skip_ends:
       if (scan->next != NULL) scan = scan->next;
       tail->next = NULL;
 
+      /* Check for class defined inside itself (self-referential loop) */
+
+      if (!strcasecmp(model, scan->name)) {
+	 Fprintf(stderr, "Fatal: Class \"%s\" is instanced inside of itself!\n",
+		scan->name);
+         InputParseError(stderr);
+	 return;
+      }
+
       /* Check for ignored class */
 
-      if ((itype = IsIgnored(subcktname, filenum)) == IGNORE_CLASS) {
+      if ((itype = IsIgnored(scan->name, filenum)) == IGNORE_CLASS) {
-          Printf("Class '%s' instanced in input but is being ignored.\n", model);
+          Printf("Class '%s' instanced in input but is being ignored.\n", scan->name);
           return;
       }
 
@@ -1788,7 +1810,7 @@ skip_ends:
                break;
          }
          if (shorted == (unsigned char)1) {
-            Printf("Instance of '%s' is shorted, ignoring.\n", subcktname);
+            Printf("Instance of '%s' is shorted, ignoring.\n", scan->name);
 	    while (head) {
 	       p = head->next;
 	       FREE(head);

base/verilog.c

@@ -76,7 +76,8 @@ struct hashdict verilogparams;
 // Global storage for verilog definitions
 struct hashdict verilogdefs;
 // Record file pointer that is associated with the hash tables
-int hashfile = -1;
+int hashfilep = -1;	/* for parameters */
+int hashfiled = -1;	/* for definitions */
 
 // Global storage for wire buses
 struct hashdict buses;
@@ -156,7 +157,8 @@ struct expr_stack {
 //-------------------------------------------------------------------------
 // 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.
+// arithmetic (+,-,*,/), grouping by parentheses, bit shifts, and
+// if-else operators.
 //
 // Returns 1 if successful, 0 on error.
 // Evaluated result is placed in the integer pointed to by "valptr".
@@ -220,6 +222,39 @@ int EvalExpr(struct expr_stack **stackptr, int *valptr)
 	    }
 	}
 
+	/* 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 == '<') {
+			/* Left shift */
+			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 == '>') {
+			/* Right shift */
+			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) {
@@ -295,6 +330,39 @@ int EvalExpr(struct expr_stack **stackptr, int *valptr)
 	    }
 	}
 
+	/* Reduce (a ? b : c) */
+
+	for (texp = start; texp; texp = texp->next) {
+	    /* There must be at least five objects on the stack */
+	    if ((texp->last != NULL) && (texp->next != NULL) && (texp->oper != '\0')
+			&& (texp->next->next != NULL)
+			&& (texp->next->next->next != NULL)) {
+		if ((texp->last->oper == '\0') && (texp->next->oper == '\0')
+			&& (texp->next->next->next->oper == '\0')) {
+		    if ((texp->oper == '?') && (texp->next->next->oper == ':')) {
+			/* If-Else conditional */
+			if (texp->last->value)
+			    texp->last->value = texp->next->value;
+			else
+			    texp->last->value = texp->next->next->next->value;
+
+			/* Remove four items from the stack */
+			tmp = texp;
+			texp = texp->last;
+			texp->next = tmp->next->next->next->next;
+			if (tmp->next->next->next->next)
+			    tmp->next->next->next->next->last = texp;
+			FREE(tmp->next->next->next);
+			FREE(tmp->next->next);
+			FREE(tmp->next);
+			FREE(tmp);
+
+			modified = TRUE;
+		    }
+		} 
+	    }
+	}
+
 	/* Reduce (a) */
 
 	for (texp = start; texp; texp = texp->next) {
@@ -373,8 +441,15 @@ int ParseIntegerExpression(char *expr, int *iptr)
 
 	if (match(sptr, "+") || match(sptr, "-")
 	    	|| match(sptr, "*") || match(sptr, "/")
-	    	|| match(sptr, "(") || match(sptr, ")")) {
+	    	|| match(sptr, "(") || match(sptr, ")")
+	    	|| match(sptr, "<<") || match(sptr, ">>")
+	    	|| match(sptr, "?") || match(sptr, ":")) {
 	    newexp = (struct expr_stack *)MALLOC(sizeof(struct expr_stack));
+	    /* Note that "oper" is one character and that "<<" and ">>"
+	     * become '<' and '>', respectively.  The less-than and greater-
+	     * than operators are not (yet) handled but will need to be
+	     * recast to some other character in "oper".
+	     */
 	    newexp->oper = *sptr;
 	    newexp->value = 0;
 	    newexp->next = NULL;
@@ -389,7 +464,7 @@ int ParseIntegerExpression(char *expr, int *iptr)
 	if ((result = sscanf(sptr, "%d", &value)) != 1) {
 
 	    // Is name in the parameter list?
-	    kl = (struct property *)HashLookup(nexttok, &verilogparams);
+	    kl = (struct property *)HashLookup(sptr, &verilogparams);
 	    if (kl == NULL) {
 		Printf("Value %s in expression is not a number or a parameter.\n",
 				sptr);
@@ -402,27 +477,29 @@ int ParseIntegerExpression(char *expr, int *iptr)
 		    if (result != 1) {
 		        Printf("Parameter %s has value %s that cannot be parsed"
 				" as an integer.\n",
-				nexttok, kl->pdefault.string);
+				sptr, kl->pdefault.string);
 		    	value = 0;
 			break;
 		    }
 		}
 		else if (kl->type == PROP_INTEGER) {
 		    value = kl->pdefault.ival;
+		    result = 1;		// Assert valid result
 		}
 		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);
+				sptr, kl->pdefault.dval);
 		    	value = 0;
 			break;
 		    }
+		    result = 1;		// Assert valid result
 		}
 		else {
 		    Printf("Parameter %s has unknown type; don't know how"
-				" to parse.\n", nexttok);
+				" to parse.\n", sptr);
 		    value = 0;
 		    break;
 		}
@@ -516,7 +593,8 @@ int GetBusTok(struct bus *wb)
 	    }
 	    else if (match(nexttok, "+") || match(nexttok, "-")
 	    		|| match(nexttok, "*") || match(nexttok, "/")
-	    		|| 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;
@@ -717,10 +795,12 @@ int GetBus(char *astr, struct bus *wb)
     return 0;
 }
 
+//--------------------------------------------------------------------
 // Output a Verilog Module.  Note that since Verilog does not describe
 // low-level devices like transistors, capacitors, etc., then this
 // format is limited to black-box subcircuits.  Cells containing any
 // such low-level devices are ignored.
+//--------------------------------------------------------------------
 
 void VerilogModule(struct nlist *tp)
 {
@@ -1408,6 +1488,9 @@ skip_endmodule:
       if (tpsave != NULL) {
 	 struct nlist *tpplace;
 	 char *savename;
+	 int lnum, pnum, ltest;
+	 unsigned char valid;
+	 struct objlist *lobj, *pobj;
 
 	 /* Handle a placeholder from a verilog file that has been replaced
 	  * by a netlist with pins in a different order.  The pins need to
@@ -1418,6 +1501,58 @@ skip_endmodule:
 	 Printf("Verilog placeholder module %s replaced by module definition\n",
 		tpsave->name);
          tpplace = LookupCellFile("_PLACEHOLDER_", filenum);
+
+	 /* If tpsave was generated from an instance in a SPICE netlist that
+	  * did not have a black-box subcircuit definition, then the pins
+	  * will all be labeled 1, 2, 3, etc.  If so, then assume that the
+	  * verilog pins are in order, and rename the placeholder pins.
+	  * If the number of pins does not match, or if the pins are not
+	  * labeled as ascending integers, then leave the cell alone.
+	  * In either case, output a warning message.
+	  */
+
+	 /* Get the number of ports in the placeholder */
+	 pnum = 0;
+	 for (pobj = tpplace->cell; pobj; pobj = pobj->next) {
+	    if (pobj->type != PORT) break;
+	    pnum++;
+	 }
+
+	 /* Get the number of ports in the saved cell and make	*/
+	 /* sure that it equals the number of ports in the	*/
+	 /* placeholder, and that all of the ports in the saved	*/
+	 /* cell are integers in ascending order.		*/
+
+	 valid = TRUE;
+	 lnum = 0;
+	 for (lobj = tpsave->cell; lobj; lobj = lobj->next) {
+	    if (lobj->type != PORT) break;
+	    lnum++;
+	    if (sscanf(lobj->name, "%d", &ltest) != 1) break;
+	    if (ltest != lnum) break;
+	 }
+	 if ((lobj != NULL) && (lobj->type == PORT))
+	    valid = FALSE;	/* Pins are not integers in ascending order */
+	 if (pnum != lnum) valid = FALSE;	/* Different number of pins */
+
+	 if (valid == TRUE) {
+	    Printf("Replacing pins of placeholder cell %s from cell definition.\n",
+		tpsave->name);
+	    pobj = tpplace->cell;
+	    for (lobj = tpsave->cell; lobj; lobj = lobj->next) {
+		if (lobj->type != PORT) break;
+		if (pobj == NULL) break;	/* should not happen */
+		FREE(lobj->name);
+		lobj->name = (char *)MALLOC(strlen(pobj->name) + 1);
+		strcpy(lobj->name, pobj->name);
+		pobj = pobj->next;
+	    }
+	 }
+	 else {
+	    Printf("Placeholder pins of cell %s are not compatible and"
+		" will be left unchanged\n", tpsave->name);
+	 }
+
          /* MatchPins is part of netcmp and normally Circuit2 is the
           * circuit being matched, so set Circuit2 to the original
           * verilog black-box cell, and MatchPins() will force its
@@ -1778,8 +1913,41 @@ skip_endmodule:
 	}
 	else {	    /* "assign" */
 	    SkipTokComments(VLOG_PIN_CHECK_DELIMITERS);
-	    if (GetBusTok(&wb) == 0) {
+	    char *aptr = strvchr(nexttok, '[');
-		char *aptr = strvchr(nexttok, '[');
+
+	    /* This is a repeat of code to handle reading of pins, and
+	     * makes sure that all input has been read to the closing
+	     * bracket.  There needs to be a single routine to do this,
+	     * or (better) rewrite the parser with lex instead of trying
+	     * to enumerate all the syntax cases separately.
+	     */
+	    if ((aptr != NULL) && (strvchr(nexttok, ']') == NULL))
+	    {
+		/* If a bus expressions has whitespace, then concatenate
+		 * 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 array in assignment %s\n", array_expr);
+		}
+	    }
+
+	    if (((aptr == NULL) && (GetBusTok(&wb) == 0)) ||
+			((aptr != NULL) && (GetBus(aptr, &wb) == 0))) {
 		if (aptr != NULL) {
 		    *aptr = '\0';
 		    /* Find object of first net in bus */
@@ -1797,6 +1965,15 @@ skip_endmodule:
 	    }
 	    else {
 		lhs = LookupObject(nexttok, CurrentCell);
+		/* Handle the case in which an assignment is made
+		 * without first declaring a wire for the signal,
+		 * which is considered valid syntax (patch by
+		 * Sylvain Munaut).
+		 */
+		if (lhs == NULL) {
+		    Node(nexttok);
+		    lhs = LookupObject(nexttok, CurrentCell);
+		}
 		strcpy(noderoot, nexttok);
 	    }
 	    SkipTokComments(VLOG_DELIMITERS);
@@ -1812,7 +1989,8 @@ skip_endmodule:
 	// Allowed uses of "assign" for netlists:
 	//    "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" using if-else constructs or bit shifts.
+	//   ("assign" using any other boolean arithmetic is not structural verilog.)
 	//    "assign a = {x{b}}" creates a bus by repeating a component.
 
 	if (nexttok && match(nexttok, "=")) {
@@ -1845,8 +2023,9 @@ skip_endmodule:
 		    break;
 		}
 		else {
-		    if (GetBusTok(&wb2) == 0) {
+		    char *aptr = strvchr(nexttok, '[');
-			char *aptr = strvchr(nexttok, '[');
+		    if (((aptr == NULL) && (GetBusTok(&wb2) == 0)) ||
+				((aptr != NULL) && (GetBus(aptr, &wb2) == 0))) {
 			j = wb2.start;
 			if (aptr != NULL) {
 			    *aptr = '\0';
@@ -2072,6 +2251,19 @@ nextinst:
 	 }
 	 SkipTokComments(VLOG_DELIMITERS);
       }
+      else if (loop.loopvar != NULL) {
+	 /* Instances created within a generate block for loop have an
+	  * implicit array
+	  */
+	 int loopval;
+	 struct property *klr;
+
+	 klr = (struct property *)HashLookup(loop.loopvar, &verilogparams);
+	 loopval = klr->pdefault.ival;
+
+         arraystart = arrayend = loopval;
+         sprintf(instancename + strlen(instancename), "[%d]", loopval);
+      }
 
       if (match(nexttok, "(")) {
 	 char savetok = (char)0;
@@ -2134,7 +2326,19 @@ nextinst:
 			 strcat(new_wire_bundle, nexttok);
 			 FREE(wire_bundle);
 			 wire_bundle = new_wire_bundle;
-			 if (!strcmp(nexttok, "}")) break;
+			 if (!strcmp(nexttok, "}"))
+			 {
+			    /* If a "bundle" has only one component, then it is
+			     * not really a bundle and should be treated as a
+			     * single wire.
+			     */
+			    if (strchr(wire_bundle, ',') == NULL) {
+				int blen = strlen(wire_bundle + 1) - 1;
+				memmove(wire_bundle, wire_bundle + 1, blen);
+				*(wire_bundle + blen) = '\0';
+			    }
+			    break;
+			 }
 			 SkipTokComments(VLOG_PIN_CHECK_DELIMITERS);
 		     }
 		     if (!nexttok) {
@@ -2510,6 +2714,7 @@ nextinst:
 	 char *brackptr;
 	 int j;
 	 char locinst[MAX_STR_LEN];
+	 int arraypos = (arraystart > arrayend) ? arraymax - i : i;
 
          if (i != -1)
 	    sprintf(locinst, "%s[%d]", instancename, i);
@@ -2546,18 +2751,27 @@ nextinst:
 	       if (scan == NULL) {
 		  char localnet[MAX_STR_LEN];
 
-		  /* Assume an implicit unconnected pin */
+		  /* Assume an implicit unconnected pin, unless there are no pins */
-		  sprintf(localnet, "_noconnect_%d_", localcount++);
+		  if (strcmp(obpinname, "(no pins)")) {
-		  Node(localnet);
+		     sprintf(localnet, "_noconnect_%d_", localcount++);
-		  join(localnet, obptr->name);
+		     Node(localnet);
-		  Fprintf(stdout,
+		     join(localnet, obptr->name);
+		     Fprintf(stdout,
 			 "Note:  Implicit pin %s in instance %s of %s in cell %s\n",
 			 obpinname, locinst, modulename, CurrentCell->name);
+		  }
 	       }
 	       else if (GetBus(scan->net, &wb) == 0) {
 		   char *bptr2;
 		   char *scanroot;
-		   scanroot = strsave(scan->net);
+		   int isbundle = FALSE;
+		   /* Skip over a bundle delimiter */
+		   if (*scan->net == '{') {
+		      scanroot = strsave(scan->net + 1);
+		      isbundle = TRUE;
+		   }
+		   else
+		      scanroot = strsave(scan->net);
 		   brackptr = strvchr(scanroot, '[');
 		   if (brackptr) *brackptr = '\0';
 
@@ -2590,6 +2804,7 @@ nextinst:
 		   else {
 		       // Instance must be an array
 		       char netname[MAX_STR_LEN];
+		       char *spos = scanroot;
 		       int slice, portlen, siglen;
 
 		       /* Get the array size of the port for bit slicing */
@@ -2601,27 +2816,49 @@ nextinst:
 		       if (siglen < 0) siglen = -siglen;
 		       siglen++;
 
-		       // If signal array is smaller than the portlength *
+		       // If this is a bundle, then count out to the current
-		       // length of instance array, then the signal wraps.
+		       // slice and read off the index.  NOTE:  Need to
+		       // handle multiple bits per bundle entry!
+		       if (isbundle) {
+			   int j;
+			   if (brackptr) *brackptr = '[';
+			   for (j = 0; j < arraypos * portlen; j++) {
+			       spos = strvchr(spos, ',');
+			       if (spos == NULL) break;
+			       spos++;
+			   }
+			   if (spos != NULL) {
+			       brackptr = strvchr(spos, '[');
+			       *brackptr = '\0';
+			       sscanf(brackptr + 1, "%d", &slice);
+			   }
+			   else spos = scanroot;  /* should emit an error here */
+		       }
+		       else {	/* not a bundle */
 
-		       if (wb2.start >= wb2.end && arraystart >= arrayend) {
+		          // If signal array is smaller than the portlength *
-			   slice = wb.start - (arraystart - i) * portlen;
+		          // length of instance array, then the signal wraps.
-			   while (slice < wb2.end) slice += siglen;
+
-		       }
+		          if (wb2.start >= wb2.end && arraystart >= arrayend) {
-		       else if (wb2.start < wb2.end && arraystart > arrayend) {
+			      slice = wb.start - (arraystart - i) * portlen;
-			   slice = wb.start + (arraystart - i) * portlen;
+			      while (slice < wb2.end) slice += siglen;
-			   while (slice > wb2.end) slice -= siglen;
+		          }
-		       }
+		          else if (wb2.start < wb2.end && arraystart > arrayend) {
-		       else if (wb2.start > wb2.end && arraystart < arrayend) {
+			      slice = wb.start + (arraystart - i) * portlen;
-			   slice = wb.start - (arraystart + i) * portlen;
+			      while (slice > wb2.end) slice -= siglen;
-			   while (slice < wb2.end) slice += siglen;
+		          }
-		       }
+		          else if (wb2.start > wb2.end && arraystart < arrayend) {
-		       else { // (wb2.start < wb2.end && arraystart < arrayend)
+			      slice = wb.start - (arraystart + i) * portlen;
-			   slice = wb.start + (arraystart + i) * portlen;
+			      while (slice < wb2.end) slice += siglen;
-			   while (slice > wb2.end) slice -= siglen;
+		          }
+		          else { // (wb2.start < wb2.end && arraystart < arrayend)
+			      slice = wb.start + (arraystart + i) * portlen;
+			      while (slice > wb2.end) slice -= siglen;
+		          }
+			  spos = scanroot;
 		       }
 
-		       sprintf(netname, "%s[%d]", scanroot, slice);
+		       sprintf(netname, "%s[%d]", spos, slice);
 	               if (LookupObject(netname, CurrentCell) == NULL) Node(netname);
 	               join(netname, obptr->name);
 		   }
@@ -2806,18 +3043,25 @@ char *ReadVerilogTop(char *fname, int *fnum, int blackbox)
      hashfunc = hashcase;
   }
 
-  if ((hashfile != -1) && (hashfile != *fnum)) {
+  if ((hashfilep != -1) && (hashfilep != *fnum)) {
-      /* Started a new file, so remove all the parameters and definitions */
+      /* Started a new file, so remove all the parameters */
       RecurseHashTable(&verilogparams, freeprop);
       HashKill(&verilogparams);
+      hashfilep = -1;
+  }
+  if ((hashfiled != -1) && (hashfiled != *fnum)) {
+      /* Started a new file, so remove all the definitions */
       RecurseHashTable(&verilogdefs, freeprop);
       HashKill(&verilogdefs);
-      hashfile = -1;
+      hashfiled = -1;
   }
-  if (hashfile == -1) {
+  if (hashfilep == -1) {
       InitializeHashTable(&verilogparams, OBJHASHSIZE);
+      hashfilep = filenum;
+  }
+  if (hashfiled == -1) {
       InitializeHashTable(&verilogdefs, OBJHASHSIZE);
-      hashfile = *fnum;
+      hashfiled = filenum;
   }
   definitions = &verilogdefs;
 

scripts/defs.mak.in

@@ -68,6 +68,7 @@ LIB_SPECS              = @LIB_SPECS@
 LIB_SPECS_NOSTUB       = @LIB_SPECS_NOSTUB@
 WISH_EXE	       = @WISH_EXE@
 TCL_LIB_DIR	       = @TCL_LIB_DIR@
+EXTRA_CFLAGS	       =
 
 CC                     = @CC@
 CPP                    = @CPP@
@@ -76,7 +77,7 @@ CXX                    = @CXX@
 CPPFLAGS               = -I. -I${NETGENDIR} @CPPFLAGS@
 DFLAGS                 = @extra_defs@ @stub_defs@ @DEFS@ -DSHDLIB_EXT=\"@SHDLIB_EXT@\" -DNDEBUG
 DFLAGS_NOSTUB          = @extra_defs@ @DEFS@ -DSHDLIB_EXT=\"@SHDLIB_EXT@\" -DNDEBUG
-CFLAGS                 = @CFLAGS@ @SHLIB_CFLAGS@ @INC_SPECS@
+CFLAGS                 = @CFLAGS@ @SHLIB_CFLAGS@ @INC_SPECS@ ${EXTRA_CFLAGS}
 
 DEPEND_FILE            = Depend
 DEPEND_FLAG            = @DEPEND_FLAG@

tcltk/netgen.tcl.in

@@ -429,7 +429,7 @@ proc netgen::lvs { name1 name2 {setupfile setup.tcl} {logfile comp.out} args} {
          set file1 $name1
          set cell1 $name1
       }
-      puts stdout "Reading netlist file $file1"
+      puts stdout "Reading netlist file $file1 for $name1"
       set fnum1 [netgen::readnet $file1]
    } else {
       set cell1 [lindex $flist1 0]
@@ -446,7 +446,7 @@ proc netgen::lvs { name1 name2 {setupfile setup.tcl} {logfile comp.out} args} {
          set file2 $name2
          set cell2 $name2
       }
-      puts stdout "Reading netlist file $file2"
+      puts stdout "Reading netlist file $file2 for $name2"
       set fnum2 [netgen::readnet $file2]
    } else {
       set cell2 [lindex $flist2 0]
@@ -461,7 +461,7 @@ proc netgen::lvs { name1 name2 {setupfile setup.tcl} {logfile comp.out} args} {
    }
 
    set clist1 [cells list $fnum1]
-   set cidx [lsearch -regexp $clist1 ^$cell1$]
+   set cidx [lsearch -exact $clist1 $cell1]
    if {$cidx < 0} {
       puts stderr "Cannot find cell $cell1 in file $file1"
       return
@@ -469,7 +469,7 @@ proc netgen::lvs { name1 name2 {setupfile setup.tcl} {logfile comp.out} args} {
       set cell1 [lindex $clist1 $cidx]
    }
    set clist2 [cells list $fnum2]
-   set cidx [lsearch -regexp $clist2 ^$cell2$]
+   set cidx [lsearch -exact $clist2 $cell2]
    if {$cidx < 0} {
       puts stderr "Cannot find cell $cell2 in file $file2"
       return
@@ -477,6 +477,18 @@ proc netgen::lvs { name1 name2 {setupfile setup.tcl} {logfile comp.out} args} {
       set cell2 [lindex $clist2 $cidx]
    }
 
+   # The "noflat" list is non-file-specific, so run on each file.
+   foreach cell $noflat {
+      set cidx [lsearch -regexp $clist1 ^$cell$]
+      if {$cidx >= 0} {
+          netgen::flatten prohibit "$fnum1 $cell"
+      }
+      set cidx [lsearch -regexp $clist2 ^$cell$]
+      if {$cidx >= 0} {
+          netgen::flatten prohibit "$fnum2 $cell"
+      }
+   }
+
    netgen::compare assign "$fnum1 $cell1" "$fnum2 $cell2"
 
    if {$setupfile == ""} {
@@ -504,6 +516,14 @@ proc netgen::lvs { name1 name2 {setupfile setup.tcl} {logfile comp.out} args} {
 	    }
 	 }
 	 close $fsetup
+      	 if {$command != {}} {
+	    # Incomplete command.  Evaluate it to get a meaningful error message
+	    if {[catch {uplevel 1 [list namespace eval netgen $command]} msg]} {
+		set msg [string trimright $msg "\n"]
+		puts stderr "Error $setupfile:$sline (ignoring), $msg"
+		incr perrors
+	    }
+	 }
       } else {
 	 puts stdout "Error:  Cannot read the setup file $setupfile"
       }
@@ -594,6 +614,9 @@ proc netgen::lvs { name1 name2 {setupfile setup.tcl} {logfile comp.out} args} {
 	    lappend properr [lindex $endval 0]
 	 } elseif {$uresult == -2} {	;# unmatched pins
 	    set doCheckFlatten 1
+	 } elseif {$uresult == -4} {	;# unmatched pins and properties
+	    lappend properr [lindex $endval 0]
+	    set doCheckFlatten 1
 	 }
       } else {
 	 # not equivalent
@@ -655,6 +678,11 @@ proc netgen::lvs { name1 name2 {setupfile setup.tcl} {logfile comp.out} args} {
 	    }
 	 } elseif {[netgen::print queue] == {} && $result == 0} {
 	    set pinMismatch 1
+	 } else {
+	    # This assumes that proxy pins are added correctly.  Previously,
+	    # that was not trusted, and so an initial pin mismatch would
+	    # always force subcells to be flattened.
+	    set doFlatten 0
 	 }
       }
       if {$doFlatten} {

tcltk/tclnetgen.c

@@ -21,6 +21,8 @@ the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 #include <stdio.h>
 #include <stdlib.h>	/* for getenv */
 #include <string.h>
+#include <strings.h>
+#include <stdarg.h>	/* for va_list */
 
 #include <tcl.h>
 
@@ -43,14 +45,14 @@ the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 #define FALSE 0
 #endif
 
+#if TCL_MAJOR_VERSION < 9
+typedef int Tcl_Size;
+#endif
+
 /*-----------------------*/
 /* Tcl 8.4 compatibility */
 /*-----------------------*/
 
-#ifndef CONST84
-#define CONST84
-#endif
-
 Tcl_Interp *netgeninterp;
 Tcl_Interp *consoleinterp;
 int ColumnBase = 0;
@@ -60,47 +62,47 @@ extern int PropertyErrorDetected;
 
 /* Function prototypes for all Tcl command callbacks */
 
-int _netgen_readnet(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_readnet(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_readlib(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_readlib(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_canonical(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_canonical(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_writenet(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_writenet(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_flatten(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_flatten(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_nodes(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_nodes(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_elements(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_elements(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_debug(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_debug(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_protochip(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_protochip(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_instances(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_instances(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_contents(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_contents(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_describe(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_describe(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_cells(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_cells(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_ports(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_ports(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_model(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_model(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_leaves(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_leaves(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_quit(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_quit(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_reinit(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_reinit(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netgen_log(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_log(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
 #ifdef HAVE_MALLINFO
-int _netgen_printmem(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_printmem(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
 #endif
-int _netgen_help(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netgen_help(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_matching(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_matching(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_compare(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_compare(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_iterate(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_iterate(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_summary(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_summary(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_print(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_print(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_format(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_format(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_run(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_run(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_verify(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_verify(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_automorphs(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_automorphs(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_equate(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_equate(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_ignore(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_ignore(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_permute(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_permute(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_property(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_property(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_exhaustive(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_exhaustive(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_symmetry(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_symmetry(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_restart(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_restart(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_global(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_global(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
-int _netcmp_convert(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST objv[]);
+int _netcmp_convert(ClientData, Tcl_Interp *, int, Tcl_Obj *const objv[]);
 
 typedef struct _Cmd {
    char 	*name;
@@ -287,7 +289,7 @@ GetTopCell(int fnum)
 int
 CommonGetFilenameOrFile(Tcl_Interp *interp, Tcl_Obj *fobj, int *fnumptr)
 {
-    int result, llen;
+    int result;
     int fnum, ftest;
     char *filename;
     struct nlist *tp;
@@ -370,7 +372,8 @@ CommonParseCell(Tcl_Interp *interp, Tcl_Obj *objv,
 	struct nlist **tpr, int *fnumptr)
 {
     Tcl_Obj *tobj, *fobj;
-    int result, llen;
+    int result;
+    Tcl_Size llen;
     int fnum, ftest, index;
     char *filename, *cellname;
     struct nlist *tp, *tp2;
@@ -399,7 +402,7 @@ CommonParseCell(Tcl_Interp *interp, Tcl_Obj *objv,
 	    Tcl_ResetResult(interp);
 
 	    /* Is 1st argument a special keyword? */
-	    if (Tcl_GetIndexFromObj(interp, tobj, (CONST84 char **)suboptions,
+	    if (Tcl_GetIndexFromObj(interp, tobj, (const char **)suboptions,
 			"special", 0, &index) == TCL_OK) {
 		switch (index) {
 		    case CIRCUIT1_IDX:
@@ -455,7 +458,7 @@ CommonParseCell(Tcl_Interp *interp, Tcl_Obj *objv,
 
 		    /* Check if 2nd item is a reserved keyword */
 		    if (Tcl_GetIndexFromObj(interp, fobj,
-				(CONST84 char **)suboptions,
+				(const char **)suboptions,
 				"special", 0, &index) == TCL_OK) {
 			switch (index) {
 			    case CIRCUIT1_IDX:
@@ -580,7 +583,7 @@ CommonParseCell(Tcl_Interp *interp, Tcl_Obj *objv,
     } else {
 	/* Only one name given;  check if it matches subOption */
 
-	if (Tcl_GetIndexFromObj(interp, objv, (CONST84 char **)suboptions,
+	if (Tcl_GetIndexFromObj(interp, objv, (const char **)suboptions,
 			"special", 0, &index) == TCL_OK) {
 
 	    switch (index) {
@@ -665,7 +668,7 @@ CommonParseCell(Tcl_Interp *interp, Tcl_Obj *objv,
 
 int
 _netgen_canonical(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
     int result;
     struct nlist *np;
@@ -704,7 +707,7 @@ _netgen_canonical(ClientData clientData,
 
 int
 _netgen_readnet(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *formats[] = {
       "automatic", "ext", "extflat", "sim", "prm", "ntk", "spice",
@@ -741,7 +744,7 @@ _netgen_readnet(ClientData clientData,
       return TCL_ERROR;
    }
    else if (objc > 1) {
-      if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)formats,
+      if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)formats,
 		"format", 0, &index) != TCL_OK) {
 	 if (objc == 3)
 
@@ -850,7 +853,7 @@ _netgen_readnet(ClientData clientData,
 
 int
 _netgen_readlib(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *formats[] = {
       "actel", "spice", "xilinx", NULL
@@ -883,7 +886,7 @@ _netgen_readlib(ClientData clientData,
       Tcl_WrongNumArgs(interp, 1, objv, "format [file]");
       return TCL_ERROR;
    }
-   if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)formats,
+   if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)formats,
 	"format", 0, &index) != TCL_OK) {
       return TCL_ERROR;
    }
@@ -930,7 +933,7 @@ _netgen_readlib(ClientData clientData,
 
 int
 _netgen_writenet(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *formats[] = {
       "ext", "sim", "ntk", "actel",
@@ -949,7 +952,7 @@ _netgen_writenet(ClientData clientData,
       Tcl_WrongNumArgs(interp, 1, objv, "format file");
       return TCL_ERROR;
    }
-   if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)formats,
+   if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)formats,
 		"format", 0, &index) != TCL_OK) {
       return TCL_ERROR;
    }
@@ -1017,11 +1020,11 @@ _netgen_writenet(ClientData clientData,
 
 int
 _netgen_flatten(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *repstr, *file;
-   int result, llen, filenum;
+   int result, filenum;
-   struct nlist *tp, *tp2;
+   struct nlist *tp, *tp2, *tptop;
 
    if ((objc < 2) || (objc > 4)) {
       Tcl_WrongNumArgs(interp, 1, objv, "?class? valid_cellname");
@@ -1035,7 +1038,7 @@ _netgen_flatten(ClientData clientData,
    if (objc >= 3) {
       char *argv = Tcl_GetString(objv[1]);
       if (!strcmp(argv, "class")) {
-	 tp = GetTopCell(filenum);
+	 tptop = GetTopCell(filenum);
 
 	 if (objc == 4) {
 	    int numflat;
@@ -1046,7 +1049,7 @@ _netgen_flatten(ClientData clientData,
 	    }
 	    else {
 	        Printf("Flattening instances of %s in cell %s within file %s\n",
-			repstr, tp2->name, tp->name);
+			repstr, tp2->name, tptop->name);
 		numflat = flattenInstancesOf(tp2->name, filenum, repstr);
 		if (numflat == 0) {
 		   Tcl_SetResult(interp, "No instances found to flatten.", NULL);
@@ -1055,15 +1058,19 @@ _netgen_flatten(ClientData clientData,
 	    }
 	 }
 	 else {
-	    Printf("Flattening instances of %s in file %s\n", repstr, tp->name);
+	    Printf("Flattening instances of %s in file %s\n", repstr, tptop->name);
             FlattenInstancesOf(repstr, filenum);
 	 }
       }
       else if (!strcmp(argv, "prohibit") || !strcmp(argv, "deny")) {
-	 tp = GetTopCell(filenum);
+	 tptop = GetTopCell(filenum);
-	 Printf("Will not flatten instances of %s in file %s\n", repstr, tp->name);
+	 if (tp == NULL)
-	 /* Mark cell as placeholder so it will not be flattened */
+	    Printf("Error:  Cell %s does not exist.\n", repstr);
-	 tp->flags |= CELL_PLACEHOLDER;
+	 else {
+	    Printf("Will not flatten instances of %s in file %s\n", repstr, tptop->name);
+	    /* Mark cell as placeholder so it will not be flattened */
+	    tp->flags |= CELL_PLACEHOLDER;
+	 }
       }
       else {
 	 Tcl_WrongNumArgs(interp, 1, objv, "class valid_cellname");
@@ -1087,7 +1094,7 @@ _netgen_flatten(ClientData clientData,
 
 int
 _netgen_nodes(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *estr = NULL, *istr = NULL, *cstr, *fstr;
    char *optstart;
@@ -1205,7 +1212,7 @@ _netgen_nodes(ClientData clientData,
 
 int
 _netgen_elements(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *nstr = NULL, *cstr;
    struct objlist * (*ListSave)();
@@ -1300,7 +1307,7 @@ _netgen_elements(ClientData clientData,
 
 int
 _netgen_debug(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *yesno[] = {
       "on", "off", NULL
@@ -1314,7 +1321,7 @@ _netgen_debug(ClientData clientData,
    if (objc == 1)
       index = YES_IDX;
    else {
-      if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)yesno,
+      if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)yesno,
 		"option", 0, &index) != TCL_OK) {
          index = CMD_IDX;
       }
@@ -1349,7 +1356,7 @@ _netgen_debug(ClientData clientData,
 
 int
 _netgen_protochip(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    if (objc != 1) {
       Tcl_WrongNumArgs(interp, 1, objv, "(no arguments)");
@@ -1369,7 +1376,7 @@ _netgen_protochip(ClientData clientData,
 
 int
 _netgen_instances(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *repstr;
    int result;
@@ -1399,7 +1406,7 @@ _netgen_instances(ClientData clientData,
 
 int
 _netgen_contents(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *repstr;
    int result;
@@ -1428,7 +1435,7 @@ _netgen_contents(ClientData clientData,
 
 int
 _netgen_describe(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *repstr;
    int file = -1;
@@ -1458,7 +1465,7 @@ _netgen_describe(ClientData clientData,
 
 int
 _netgen_cells(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *repstr, *filename = NULL;
    char *optstart;
@@ -1545,7 +1552,7 @@ _netgen_cells(ClientData clientData,
 
 int
 _netgen_model(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    struct nlist *tp, *tp2;
    char *model, *retclass;
@@ -1595,10 +1602,9 @@ _netgen_model(ClientData clientData,
       return result;
 
    if (objc == 3) {
-      model = Tcl_GetString(objv[2]);
+      nports = NumberOfPorts(tp->name, fnum);
-      nports = NumberOfPorts(model, fnum);
 
-      if (Tcl_GetIndexFromObj(interp, objv[2], (CONST84 char **)modelclasses,
+      if (Tcl_GetIndexFromObj(interp, objv[2], (const char **)modelclasses,
 		"class", 0, &index) != TCL_OK) {
 	 return TCL_ERROR;
       }
@@ -1768,7 +1774,7 @@ wrongNumPorts:
 
 int
 _netgen_ports(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *repstr;
    int result;
@@ -1798,7 +1804,7 @@ _netgen_ports(ClientData clientData,
 
 int
 _netgen_leaves(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *repstr;
    int result;
@@ -1834,7 +1840,7 @@ _netgen_leaves(ClientData clientData,
 
 int
 _netgen_quit(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    if (objc != 1) {
       Tcl_WrongNumArgs(interp, 1, objv, "(no arguments)");
@@ -1862,7 +1868,7 @@ _netgen_quit(ClientData clientData,
 
 int
 _netgen_reinit(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    if (objc != 1) {
       Tcl_WrongNumArgs(interp, 1, objv, "(no arguments)");
@@ -1882,7 +1888,7 @@ _netgen_reinit(ClientData clientData,
 
 int
 _netgen_log(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *yesno[] = {
       "start", "end", "reset", "suspend", "resume", "file", "echo", "put", NULL
@@ -1899,7 +1905,7 @@ _netgen_log(ClientData clientData,
       index = (LoggingFile) ? RESUME_IDX : START_IDX;
    }
    else {
-      if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)yesno,
+      if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)yesno,
 		"option", 0, &index) != TCL_OK) {
 	 return TCL_ERROR;
       }
@@ -2026,7 +2032,7 @@ _netgen_log(ClientData clientData,
 
 int
 _netgen_printmem(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    if (objc != 1) {
       Tcl_WrongNumArgs(interp, 1, objv, "(no arguments)");
@@ -2048,7 +2054,7 @@ _netgen_printmem(ClientData clientData,
 
 int
 _netcmp_format(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
     int col1_width = 41, col2_width = 41;
 
@@ -2109,13 +2115,13 @@ _netcmp_format(ClientData clientData,
 
 int
 _netcmp_compare(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *name1, *name2, *file1, *file2, *optstart;
    int fnum1, fnum2, dolist = 0;
    int dohierarchy = FALSE;
    int assignonly = FALSE;
-   int argstart = 1, qresult, llen, result;
+   int argstart = 1, qresult, result;
    int hascontents1, hascontents2;
    struct Correspond *nextcomp;
    struct nlist *tp1 = NULL, *tp2 = NULL;
@@ -2286,7 +2292,7 @@ _netcmp_compare(ClientData clientData,
 
 int
 _netcmp_iterate(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    if (objc != 1) {
       Tcl_WrongNumArgs(interp, 1, objv, "(no arguments)");
@@ -2310,7 +2316,7 @@ _netcmp_iterate(ClientData clientData,
 
 int
 _netcmp_summary(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *options[] = {
       "nodes", "elements", NULL
@@ -2325,7 +2331,7 @@ _netcmp_summary(ClientData clientData,
       return TCL_ERROR;
    }
    if (objc == 2) {
-      if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)options,
+      if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)options,
 		"option", 0, &index) != TCL_OK) {
          return TCL_ERROR;
       }
@@ -2351,7 +2357,7 @@ _netcmp_summary(ClientData clientData,
 
 int
 _netcmp_print(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *options[] = {
       "nodes", "elements", "queue", NULL
@@ -2389,16 +2395,16 @@ _netcmp_print(ClientData clientData,
       return TCL_ERROR;
    }
    if (objc >= 2) {
-      if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)options,
+      if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)options,
 		"option", 0, &index) != TCL_OK) {
 	 if ((objc == 2) && (Tcl_GetIndexFromObj(interp, objv[1],
-		(CONST84 char **)classes, "class", 0, &class) != TCL_OK)) {
+		(const char **)classes, "class", 0, &class) != TCL_OK)) {
             return TCL_ERROR;
 	 }
       }
    }
    if (objc == 3 && index != QUEUE_IDX) {
-      if (Tcl_GetIndexFromObj(interp, objv[2], (CONST84 char **)classes,
+      if (Tcl_GetIndexFromObj(interp, objv[2], (const char **)classes,
 		"class", 0, &class) != TCL_OK) {
          return TCL_ERROR;
       }
@@ -2442,7 +2448,7 @@ _netcmp_print(ClientData clientData,
 
 int
 _netcmp_run(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *options[] = {
       "converge", "resolve", NULL
@@ -2469,7 +2475,7 @@ _netcmp_run(ClientData clientData,
    if (objc == 1)
       index = RESOLVE_IDX;
    else {
-      if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)options,
+      if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)options,
 		"option", 0, &index) != TCL_OK) {
          return TCL_ERROR;
       }
@@ -2513,7 +2519,13 @@ _netcmp_run(ClientData clientData,
 	       if (automorphisms > 0) {
 	          // Next, attempt to resolve automorphisms uniquely by
 	          // using the pin names
-		  automorphisms = ResolveAutomorphsByPin();
+		  automorphisms = ResolveAutomorphsByPin(FALSE);
+	       }
+	       if (automorphisms > 0) {
+	          // Next, attempt to resolve automorphisms uniquely by
+	          // using the net names (should only be done after
+		  // resolving by pin).
+		  automorphisms = ResolveAutomorphsByPin(TRUE);
 	       }
 	       if (automorphisms > 0) {
 	          // Anything left is truly indistinguishable
@@ -2523,8 +2535,16 @@ _netcmp_run(ClientData clientData,
 
 	    if (automorphisms == -1)
 	       Fprintf(stdout, "Netlists do not match.\n");
-	    else if (automorphisms == -2)
+	    else if (automorphisms == -2) {
-	       Fprintf(stdout, "Netlists match uniquely with port errors.\n");
+	       Fprintf(stdout, "Netlists match uniquely with port");
+	       if (PropertyErrorDetected) {
+		  Fprintf(stdout, " and property errors.\n");
+	          PrintPropertyResults(dolist);
+	       }
+	       else {
+		  Fprintf(stdout, " errors.\n");
+	       }
+	    }
 	    else {
 	       if (automorphisms == 0)
 	          Fprintf(stdout, "Netlists match uniquely");
@@ -2559,6 +2579,7 @@ _netcmp_run(ClientData clientData,
 /*	 0: not verified				*/
 /*	-1: no elements or nodes			*/
 /*	-3: verified with property error		*/
+/*	-4: verified with property and port errors	*/
 /*   equiv option					*/
 /*	-2: pin mismatch				*/
 /*							*/
@@ -2571,7 +2592,7 @@ _netcmp_run(ClientData clientData,
 
 int
 _netcmp_verify(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *options[] = {
       "nodes", "elements", "properties", "only", "all", "equivalent", "unique", NULL
@@ -2603,7 +2624,7 @@ _netcmp_verify(ClientData clientData,
       return TCL_ERROR;
    }
    if (objc == 2) {
-      if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)options,
+      if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)options,
 		"option", 0, &index) != TCL_OK) {
          return TCL_ERROR;
       }
@@ -2652,14 +2673,20 @@ _netcmp_verify(ClientData clientData,
 	 disable_interrupt();
 	 if (index == EQUIV_IDX || index == UNIQUE_IDX)
 	     Tcl_SetObjResult(interp, Tcl_NewBooleanObj(0));
-	 else
+	 else {
 	     Fprintf(stdout, "Netlists do not match.\n");
+	     Fprintf(stdout, "Port matching may fail to disambiguate symmetries.\n");
+	 }
       }
       else if (automorphisms == -2) {
 	 if (index == EQUIV_IDX)
 	    Tcl_SetObjResult(interp, Tcl_NewBooleanObj(1));
-	 else if (index == UNIQUE_IDX)
+	 else if (index == UNIQUE_IDX) {
-	    Tcl_SetObjResult(interp, Tcl_NewIntObj(-2));
+	    if (PropertyErrorDetected == 0)
+	       Tcl_SetObjResult(interp, Tcl_NewIntObj(-2));
+	    else
+	       Tcl_SetObjResult(interp, Tcl_NewIntObj(-4));
+	 }
 	 else if (index > 0)
 	    Fprintf(stdout, "Circuits match uniquely with port errors.\n");
       }
@@ -2754,7 +2781,7 @@ _netcmp_verify(ClientData clientData,
 
 int
 _netcmp_automorphs(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    if (objc != 1) {
       Tcl_WrongNumArgs(interp, 1, objv, "(no arguments)");
@@ -2775,7 +2802,7 @@ _netcmp_automorphs(ClientData clientData,
 
 int
 _netcmp_convert(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
     char *cellname;
     int filenum = -1;
@@ -2805,10 +2832,10 @@ _netcmp_convert(ClientData clientData,
 
 int
 _netcmp_global(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *filename, *cellname, *pattern;
-   int numchanged = 0, p, fnum, llen, result;
+   int numchanged = 0, p, fnum, result;
    struct nlist *tp;
 
    if (objc < 2) {
@@ -2842,7 +2869,7 @@ _netcmp_global(ClientData clientData,
 
 int
 _netcmp_ignore(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *options[] = {
       "class", "shorted", NULL
@@ -2856,7 +2883,7 @@ _netcmp_ignore(ClientData clientData,
    char *name = NULL, *name2 = NULL;
 
    if (objc >= 3) {
-      if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)options,
+      if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)options,
 		"option", 0, &index) == TCL_OK) {
 	 objc--;
 	 objv++;
@@ -2890,7 +2917,7 @@ _netcmp_ignore(ClientData clientData,
 
 int
 _netcmp_equate(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *options[] = {
       "nodes", "elements", "classes", "pins", NULL
@@ -2905,7 +2932,8 @@ _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, dounique = 0;
+   int i, dolist = 0, doforce = 0, dounique = 0;
+   Tcl_Size l1, l2, lent, ltest;
    Tcl_Obj *tobj1, *tobj2, *tobj3;
 
    while (objc > 1) {
@@ -2935,7 +2963,7 @@ _netcmp_equate(ClientData clientData,
       return TCL_ERROR;
    }
    else {
-      if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)options,
+      if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)options,
 		"option", 0, &index) != TCL_OK) {
          return TCL_ERROR;
       }
@@ -3404,22 +3432,31 @@ _netcmp_equate(ClientData clientData,
 
 int
 _netcmp_property(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
-    int fnum, i, llen;
+    int fnum, i;
     struct nlist *tp;
     struct property *kl, *kllast, *klnext;
     Tcl_Obj *tobj1, *tobj2, *tobj3;
+    Tcl_Size llen;
     double dval;
     int ival, argstart;
 
+    char *topoptions[] = {
+	"default", "series", "serial", "parallel", "topology", NULL
+    };
+    enum TopOptionIdx {
+	TOP_DEFAULT_IDX, TOP_SERIES_IDX, TOP_SERIAL_IDX, TOP_PARALLEL_IDX,
+	TOP_TOPOLOGY_IDX
+    };
+
     char *options[] = {
 	"add", "create", "remove", "delete", "tolerance", "merge", "serial",
-	"series", "parallel", "associate", "topology", NULL
+	"series", "parallel", "associate", "derive", NULL
     };
     enum OptionIdx {
 	ADD_IDX, CREATE_IDX, REMOVE_IDX, DELETE_IDX, TOLERANCE_IDX, MERGE_IDX,
-	SERIAL_IDX, SERIES_IDX, PARALLEL_IDX, ASSOCIATE_IDX, TOPOLOGY_IDX
+	SERIAL_IDX, SERIES_IDX, PARALLEL_IDX, ASSOCIATE_IDX, DERIVE_IDX
     };
     int result, index, idx2;
 
@@ -3454,6 +3491,14 @@ _netcmp_property(ClientData clientData,
 	COMB_NONE_IDX, COMB_PAR_IDX, COMB_ADD_IDX, COMB_CRITICAL_IDX
     };
 
+    char *deriveoptions[] = {
+	"area", "perimeter", NULL
+    };
+
+    enum DeriveOptionIdx {
+	AREA_IDX, PERIMETER_IDX
+    };
+
     char *yesno[] = {
 	"on", "yes", "true", "enable", "allow",
 	"off", "no", "false", "disable", "prohibit", NULL
@@ -3468,8 +3513,13 @@ _netcmp_property(ClientData clientData,
 	"strict", "relaxed", NULL
     };
 
+    /* Don't need to check return value */
+    index = -1;
+    Tcl_GetIndexFromObj(interp, objv[1], (const char **)topoptions,
+		"option", 0, &index);
+
     /* Check for special command "property default" */
-    if ((objc == 2) && (!strcmp(Tcl_GetString(objv[1]), "default"))) {
+    if ((objc == 2) && (index == TOP_DEFAULT_IDX)) {
 
 	/* For each FET device, do "merge {w add_critical}" and	*/
 	/* "remove as ad ps pd".  This allows parallel devices	*/
@@ -3516,7 +3566,7 @@ _netcmp_property(ClientData clientData,
 	}
 	return TCL_OK;
     }
-    else if ((objc == 3) && (!strcmp(Tcl_GetString(objv[1]), "parallel"))) {
+    else if ((objc == 3) && (index == TOP_PARALLEL_IDX)) {
 	if (!strcmp(Tcl_GetString(objv[2]), "none")) {
 	    GlobalParallelNone = TRUE;
 	    SetParallelCombine(FALSE);
@@ -3538,8 +3588,7 @@ _netcmp_property(ClientData clientData,
 	}
 	return TCL_OK;
     }
-    else if ((objc == 3) && ((!strcmp(Tcl_GetString(objv[1]), "series")) ||
+    else if ((objc == 3) && ((index == TOP_SERIES_IDX) || (index == TOP_SERIAL_IDX))) {
-		(!strcmp(Tcl_GetString(objv[1]), "serial")))) {
 	if (!strcmp(Tcl_GetString(objv[2]), "none")) {
 	    SetSeriesCombine(FALSE);
 	}
@@ -3553,7 +3602,7 @@ _netcmp_property(ClientData clientData,
 	}
 	return TCL_OK;
     }
-    else if ((objc > 1) && (!strcmp(Tcl_GetString(objv[1]), "topology"))) {
+    else if ((objc > 1) && (index == TOP_TOPOLOGY_IDX)) {
 	if (objc == 2) {
 	    if (ExactTopology)
 		Tcl_SetResult(interp, "Strict topology property matching.",
@@ -3564,7 +3613,7 @@ _netcmp_property(ClientData clientData,
 	}
 	else if (objc == 3) {
 	    if (Tcl_GetIndexFromObj(interp, objv[2],
-			(CONST84 char **)topo,
+			(const char **)topo,
 			"topology", 0, &idx2) == TCL_OK) {
 		if (idx2 == 0)
 		    ExactTopology = TRUE;
@@ -3623,7 +3672,7 @@ _netcmp_property(ClientData clientData,
 	Tcl_SetObjResult(interp, tobj1);
     }
     else {
-	if (Tcl_GetIndexFromObj(interp, objv[2], (CONST84 char **)options,
+	if (Tcl_GetIndexFromObj(interp, objv[2], (const char **)options,
 		"option", 0, &index) != TCL_OK) {
 	    index = ADD_IDX;
 	    argstart = 2;
@@ -3656,7 +3705,7 @@ _netcmp_property(ClientData clientData,
 		    // Each value must be a list of two, or a yes/no answer.
 
 		    if (Tcl_GetIndexFromObj(interp, objv[i],
-				(CONST84 char **)yesno,
+				(const char **)yesno,
 				"combine", 0, &idx2) == TCL_OK) {
 			if (idx2 <= 4) {	/* true, enable, etc. */
 			    if (index == SERIAL_IDX || index == SERIES_IDX)
@@ -3688,7 +3737,7 @@ _netcmp_property(ClientData clientData,
 			if (result != TCL_OK) return result;
 
 			result = Tcl_GetIndexFromObj(interp, tobj2,
-				(CONST84 char **)combineoptions,
+				(const char **)combineoptions,
 				"combine_type", 0, &idx2);
 			if (result != TCL_OK) return result;
 
@@ -3773,7 +3822,7 @@ _netcmp_property(ClientData clientData,
 			    /* {key, type} or {key, tolerance} duplet */
 
 			    if (Tcl_GetIndexFromObj(interp, tobj2,
-					(CONST84 char **)suboptions,
+					(const char **)suboptions,
 					"type", 0, &idx2) != TCL_OK) {
 				Tcl_ResetResult(interp);
 				if (Tcl_GetDoubleFromObj(interp, tobj2, &dval)
@@ -3817,7 +3866,7 @@ _netcmp_property(ClientData clientData,
 			    /* {key, type, tolerance} triplet */
 
 			    if (Tcl_GetIndexFromObj(interp, tobj2,
-					(CONST84 char **)suboptions,
+					(const char **)suboptions,
 					"type", 0, &idx2) != TCL_OK)
 				return TCL_ERROR;
 
@@ -3960,7 +4009,7 @@ _netcmp_property(ClientData clientData,
 			if (result != TCL_OK) return result;
 
 			result = Tcl_GetIndexFromObj(interp, tobj2,
-				(CONST84 char **)mergeoptions,
+				(const char **)mergeoptions,
 				"merge_type", 0, &idx2);
 			if (result != TCL_OK) return result;
 
@@ -3999,6 +4048,32 @@ _netcmp_property(ClientData clientData,
 		}
 		break;
 
+	    case DERIVE_IDX:
+		/* Create a derived property.  For now, this just creates
+		 * "area" or "perimeter" properties.  There may not (?)
+		 * be enough cause to make other ones.  Unlike other
+		 * "property" options, this option causes the whole circuit
+		 * database to be searched for the device in question, and
+		 * the new property is added.
+		 */
+		if (objc < 6) {
+		    Tcl_WrongNumArgs(interp, 2, objv, "{area|perimeter width length}");
+		    return TCL_ERROR;
+		}
+		result = Tcl_GetIndexFromObj(interp, objv[3],
+			(const char **)deriveoptions,
+			"area|perimeter", 0, &idx2);
+		if (result != TCL_OK) return result;
+		switch (idx2) {
+		    case AREA_IDX:
+			DeriveAreaProperty(tp, fnum, Tcl_GetString(objv[4]),
+				Tcl_GetString(objv[5]));
+			break;
+		    case PERIMETER_IDX:
+			DerivePerimeterProperty(tp, fnum, Tcl_GetString(objv[4]),
+				Tcl_GetString(objv[5]));
+			break;
+		}
 	}
     }
     return TCL_OK;
@@ -4018,7 +4093,7 @@ _netcmp_property(ClientData clientData,
 
 int
 _netcmp_permute(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *model, *pin1, *pin2;
    char *permuteclass[] = {
@@ -4039,7 +4114,7 @@ _netcmp_permute(ClientData clientData,
       index = DEFLT_IDX;
    }
    else {
-      if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)permuteclass,
+      if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)permuteclass,
 		"permute class", 0, &index) != TCL_OK) {
 	    if (objc != 4) {
 		Tcl_WrongNumArgs(interp, 1, objv, "?valid_cellname pin1 pin2?");
@@ -4159,7 +4234,7 @@ _netcmp_permute(ClientData clientData,
 
 int
 _netcmp_symmetry(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    Printf("Symmetry breaking method has been deprecated.\n");
    return TCL_OK;
@@ -4175,7 +4250,7 @@ _netcmp_symmetry(ClientData clientData,
 
 int
 _netcmp_exhaustive(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *yesno[] = {
       "on", "off", NULL
@@ -4188,7 +4263,7 @@ _netcmp_exhaustive(ClientData clientData,
    if (objc == 1)
       index = -1;
    else {
-      if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)yesno,
+      if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)yesno,
 		"option", 0, &index) != TCL_OK)
          return TCL_ERROR;
    }
@@ -4217,7 +4292,7 @@ _netcmp_exhaustive(ClientData clientData,
 
 int
 _netcmp_restart(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    if (objc != 1) {
       Tcl_WrongNumArgs(interp, 1, objv, "(no arguments)");
@@ -4237,7 +4312,7 @@ _netcmp_restart(ClientData clientData,
 
 int
 _netgen_help(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    int n;
 
@@ -4268,7 +4343,7 @@ _netgen_help(ClientData clientData,
 
 int
 _netcmp_matching(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    char *options[] = {
       "nodes", "elements", NULL
@@ -4290,7 +4365,7 @@ _netcmp_matching(ClientData clientData,
       name = Tcl_GetString(objv[1]);
    }
    else {
-      if (Tcl_GetIndexFromObj(interp, objv[1], (CONST84 char **)options,
+      if (Tcl_GetIndexFromObj(interp, objv[1], (const char **)options,
 		"option", 0, &index) != TCL_OK) {
          return TCL_ERROR;
       }
@@ -4419,14 +4494,14 @@ void tcl_vprintf(FILE *f, const char *fmt, va_list args_in)
 
 void tcl_stdflush(FILE *f)
 {   
-   Tcl_SavedResult state;
+   Tcl_InterpState state;
    static char stdstr[] = "::flush stdxxx";
    char *stdptr = stdstr + 11;
     
-   Tcl_SaveResult(netgeninterp, &state);
+   state = Tcl_SaveInterpState(netgeninterp, TCL_OK);
    strcpy(stdptr, (f == stderr) ? "err" : "out");
    Tcl_Eval(netgeninterp, stdstr);
-   Tcl_RestoreResult(netgeninterp, &state);
+   Tcl_RestoreInterpState(netgeninterp, state);
 }
 
 /*------------------------------------------------------*/
@@ -4456,7 +4531,7 @@ char *Tcl_Strdup(const char *s)
 /*------------------------------------------------------*/
 
 int _tkcon_interrupt(ClientData clientData,
-    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
+    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
    InterruptPending = 1;
    return TCL_OK;
@@ -4495,7 +4570,7 @@ int Tclnetgen_Init(Tcl_Interp *interp)
    /* Remember the interpreter */
    netgeninterp = interp;
 
-   if (Tcl_InitStubs(interp, "8.5", 0) == NULL) return TCL_ERROR;
+   if (Tcl_InitStubs(interp, TCL_VERSION, 0) == NULL) return TCL_ERROR;
   
    for (n = 0; netgen_cmds[n].name != NULL; n++) {
       sprintf(keyword, "netgen::%s", netgen_cmds[n].name);
@@ -4504,7 +4579,8 @@ int Tclnetgen_Init(Tcl_Interp *interp)
    }
    for (n = 0; netcmp_cmds[n].name != NULL; n++) {
       sprintf(keyword, "netgen::%s", netcmp_cmds[n].name);
-      Tcl_CreateObjCommand(interp, keyword, netcmp_cmds[n].handler,
+      Tcl_CreateObjCommand(interp, keyword,
+		(Tcl_ObjCmdProc *)netcmp_cmds[n].handler,
 		(ClientData)NULL, (Tcl_CmdDeleteProc *)NULL);
    }
 

tcltk/tkcon.tcl

@@ -36,7 +36,7 @@ exec ${NETGEN_WISH:=wish} "$0" ${1+"$@"}
 #
 #    set ::tkcon::PRIV(proxy) {wwwproxy:8080 1}
 #
-# Or you can set the above variable from within tkcon by calling 
+# Or you can set the above variable from within tkcon by calling
 #
 #    tkcon master set ::tkcon:PRIV(proxy) wwwproxy:8080
 #
@@ -44,6 +44,8 @@ exec ${NETGEN_WISH:=wish} "$0" ${1+"$@"}
 if {$tcl_version < 8.0} {
     return -code error "tkcon requires at least Tcl/Tk8"
 } else {
+    # Prevent breaking on version 8.5.2
+    # package require -exact Tk $tcl_version
     package require Tk $tcl_version
 }
 
@@ -59,18 +61,6 @@ foreach pkg [info loaded {}] {
 }
 catch {unset pkg file name version}
 
-# Tk 8.4 makes previously exposed stuff private.
-# FIX: Update tkcon to not rely on the private Tk code.
-#
-if {![llength [info globals tkPriv]]} {
-    ::tk::unsupported::ExposePrivateVariable tkPriv
-}
-foreach cmd {SetCursor UpDownLine Transpose ScrollPages} {
-    if {![llength [info commands tkText$cmd]]} {
-        ::tk::unsupported::ExposePrivateCommand tkText$cmd
-    }
-}
-
 # Initialize the ::tkcon namespace
 #
 namespace eval ::tkcon {
@@ -196,7 +186,7 @@ proc ::tkcon::Init {} {
 	    tkcon_puts tkcon_gets observe observe_var unalias which what
 	}
 	version		2.3
-	RCS		{RCS: @(#) $Id: tkcon.tcl,v 1.2 2008/05/23 00:20:17 tim Exp $}
+	RCS		{RCS: @(#) $Id: tkcon.tcl,v 1.2 2008/04/18 16:28:13 tim Exp $}
 	HEADURL		{http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/tkcon/tkcon/tkcon.tcl?rev=HEAD}
 	docs		"http://tkcon.sourceforge.net/"
 	email		{jeff@hobbs.org}
@@ -654,7 +644,7 @@ proc ::tkcon::GarbageCollect {} {
 ## ::tkcon::EvalCmd) in turn.  Any uncompleted command will not be eval'ed.
 # ARGS:	w	- console text widget
 # Calls:	::tkcon::CmdGet, ::tkcon::CmdSep, ::tkcon::EvalCmd
-## 
+##
 proc ::tkcon::Eval {w} {
     set incomplete [CmdSep [CmdGet $w] cmds last]
     $w mark set insert end-1c
@@ -674,7 +664,7 @@ proc ::tkcon::Eval {w} {
 # Calls:	::tkcon::Prompt
 # Outputs:	result of command to stdout (or stderr if error occured)
 # Returns:	next event number
-## 
+##
 proc ::tkcon::EvalCmd {w cmd} {
     variable OPT
     variable PRIV
@@ -745,7 +735,7 @@ proc ::tkcon::EvalCmd {w cmd} {
 		    $w tag bind $tag <Leave> \
 			    [list $w tag configure $tag -underline 0]
 		    $w tag bind $tag <ButtonRelease-1> \
-			    "if {!\[info exists tkPriv(mouseMoved)\] || !\$tkPriv(mouseMoved)} \
+			    "if {!\[info exists ::tk::Priv(mouseMoved)\] || !\$::tk::Priv(mouseMoved)} \
 			    {[list edit -attach [Attach] -type error -- $PRIV(errorInfo)]}"
 		} else {
 		    $w insert output $res\n stderr
@@ -905,7 +895,7 @@ proc ::tkcon::EvalSocketClosed {} {
 ## ::tkcon::EvalNamespace - evaluates the args in a particular namespace
 ## This is an override for ::tkcon::EvalAttached for when the user wants
 ## to attach to a particular namespace of the attached interp
-# ARGS:	attached	
+# ARGS:	attached
 #	namespace	the namespace to evaluate in
 #	args		the args to evaluate
 # RETURNS:	the result of the command
@@ -933,7 +923,7 @@ proc ::tkcon::Namespaces {{ns ::} {l {}}} {
 ## ::tkcon::CmdGet - gets the current command from the console widget
 # ARGS:	w	- console text widget
 # Returns:	text which compromises current command line
-## 
+##
 proc ::tkcon::CmdGet w {
     if {![llength [$w tag nextrange prompt limit end]]} {
 	$w tag add stdin limit end-1c
@@ -947,7 +937,7 @@ proc ::tkcon::CmdGet w {
 #	last	- varname of any remainder (like an incomplete final command).
 #		If there is only one command, it's placed in this var.
 # Returns:	constituent command info in varnames specified by list & rmd.
-## 
+##
 proc ::tkcon::CmdSep {cmd list last} {
     upvar 1 $list cmds $last inc
     set inc {}
@@ -974,7 +964,7 @@ proc ::tkcon::CmdSep {cmd list last} {
 ## ::tkcon::CmdSplit - splits multiple commands into a list
 # ARGS:	cmd	- (possible) multiple command to separate
 # Returns:	constituent commands in a list
-## 
+##
 proc ::tkcon::CmdSplit {cmd} {
     set inc {}
     set cmds {}
@@ -998,7 +988,7 @@ proc ::tkcon::CmdSplit {cmd} {
 ## Called by ::tkcon::EvalCmd
 # ARGS:	w	- text widget
 # Outputs:	tag name guaranteed unique in the widget
-## 
+##
 proc ::tkcon::UniqueTag {w} {
     set tags [$w tag names]
     set idx 0
@@ -1011,7 +1001,7 @@ proc ::tkcon::UniqueTag {w} {
 # ARGS:	w	- console text widget
 #	size	- # of lines to constrain to
 # Outputs:	may delete data in console widget
-## 
+##
 proc ::tkcon::ConstrainBuffer {w size} {
     if {[$w index end] > $size} {
 	$w delete 1.0 [expr {int([$w index end])-$size}].0
@@ -1021,7 +1011,7 @@ proc ::tkcon::ConstrainBuffer {w size} {
 ## ::tkcon::Prompt - displays the prompt in the console widget
 # ARGS:	w	- console text widget
 # Outputs:	prompt (specified in ::tkcon::OPT(prompt1)) to console
-## 
+##
 proc ::tkcon::Prompt {{pre {}} {post {}} {prompt {}}} {
     variable OPT
     variable PRIV
@@ -1053,7 +1043,7 @@ proc ::tkcon::Prompt {{pre {}} {post {}} {prompt {}}} {
 }
 
 ## ::tkcon::About - gives about info for tkcon
-## 
+##
 proc ::tkcon::About {} {
     variable OPT
     variable PRIV
@@ -1088,7 +1078,7 @@ proc ::tkcon::About {} {
 
 ## ::tkcon::InitMenus - inits the menubar and popup for the console
 # ARGS:	w	- console text widget
-## 
+##
 proc ::tkcon::InitMenus {w title} {
     variable OPT
     variable PRIV
@@ -1521,7 +1511,7 @@ proc ::tkcon::NamespaceMenu m {
     }
 }
 
-## Namepaces List 
+## Namepaces List
 ##
 proc ::tkcon::NamespacesList {names} {
     variable PRIV
@@ -1894,7 +1884,7 @@ proc ::tkcon::NewSocket {} {
 ## The file is actually sourced in the currently attached's interp
 # ARGS:	fn	- (optional) filename to source in
 # Returns:	selected filename ({} if nothing was selected)
-## 
+##
 proc ::tkcon::Load { {fn ""} } {
     set types {
 	{{Tcl Files}	{.tcl .tk}}
@@ -1913,7 +1903,7 @@ proc ::tkcon::Load { {fn ""} } {
 ## This does not eval in a slave because it's not necessary
 # ARGS:	w	- console text widget
 # 	fn	- (optional) filename to save to
-## 
+##
 proc ::tkcon::Save { {fn ""} {type ""} {opt ""} {mode w} } {
     variable PRIV
 
@@ -1983,7 +1973,7 @@ proc ::tkcon::MainInit {} {
     ## Creates a slave interpreter and sources in this script.
     ## All other interpreters also get a command to eval function in the
     ## new interpreter.
-    ## 
+    ##
     proc ::tkcon::New {} {
 	variable PRIV
 	global argv0 argc argv
@@ -2020,7 +2010,7 @@ proc ::tkcon::MainInit {} {
     ## ::tkcon::Exit - full exit OR destroy slave console
     ## This proc should only be called in the main interpreter from a slave.
     ## The master determines whether we do a full exit or just kill the slave.
-    ## 
+    ##
     proc ::tkcon::Exit {slave args} {
 	variable PRIV
 	variable OPT
@@ -2043,7 +2033,7 @@ proc ::tkcon::MainInit {} {
     ## This proc should only be called by the main interpreter.  If it is
     ## called from there, it will ask before exiting tkcon.  All others
     ## (slaves) will just have their slave interpreter deleted, closing them.
-    ## 
+    ##
     proc ::tkcon::Destroy {{slave {}}} {
 	variable PRIV
 
@@ -2474,7 +2464,7 @@ proc ::tkcon::ErrorHighlight w {
 	    $w tag configure $tag -foreground $COLOR(stdout)
 	    $w tag bind $tag <Enter> [list $w tag configure $tag -underline 1]
 	    $w tag bind $tag <Leave> [list $w tag configure $tag -underline 0]
-	    $w tag bind $tag <ButtonRelease-1> "if {!\$tkPriv(mouseMoved)} \
+	    $w tag bind $tag <ButtonRelease-1> "if {!\$::tk::Priv(mouseMoved)} \
 		    {[list edit -attach $app -type proc -find $what -- $cmd]}"
 	}
 	set info [string range $info $c1 end]
@@ -2503,7 +2493,7 @@ proc ::tkcon::ErrorHighlight w {
 	    $w tag configure $tag -foreground $COLOR(proc)
 	    $w tag bind $tag <Enter> [list $w tag configure $tag -underline 1]
 	    $w tag bind $tag <Leave> [list $w tag configure $tag -underline 0]
-	    $w tag bind $tag <ButtonRelease-1> "if {!\$tkPriv(mouseMoved)} \
+	    $w tag bind $tag <ButtonRelease-1> "if {!\$::tk::Priv(mouseMoved)} \
 		    {[list edit -attach $app -type proc -- $cmd]}"
 	}
     }
@@ -2513,7 +2503,7 @@ proc ::tkcon::ErrorHighlight w {
 ## This always exists in the main interpreter, and is aliased into
 ## other connected interpreters
 # ARGS:	totally variable, see internal comments
-## 
+##
 proc tkcon {cmd args} {
     global errorInfo
 
@@ -2552,8 +2542,8 @@ proc tkcon {cmd args} {
 	    ## 'congets' a replacement for [gets stdin]
 	    # Use the 'gets' alias of 'tkcon_gets' command instead of
 	    # calling the *get* methods directly for best compatability
-	    if {[llength $args]} {
+	    if {[llength $args] > 1} {
-		return -code error "wrong # args: must be \"tkcon congets\""
+		return -code error "wrong # args: must be \"tkcon congets [pfix]\""
 	    }
 	    tkcon show
 	    set old [bind TkConsole <<TkCon_Eval>>]
@@ -2561,7 +2551,12 @@ proc tkcon {cmd args} {
 	    set w $::tkcon::PRIV(console)
 	    # Make sure to move the limit to get the right data
 	    $w mark set insert end
-	    $w mark set limit insert
+	    if {[llength $args]} {
+		$w mark set limit insert
+		$w insert end $args
+	    } else {
+	        $w mark set limit insert
+	    }
 	    $w see end
 	    vwait ::tkcon::PRIV(wait)
 	    set line [::tkcon::CmdGet $w]
@@ -2790,21 +2785,27 @@ proc tkcon {cmd args} {
 ## This allows me to capture all stdout/stderr to the console window
 ## This will be renamed to 'puts' at the appropriate time during init
 ##
-# ARGS:	same as usual	
+# ARGS:	same as usual
 # Outputs:	the string with a color-coded text tag
-## 
+##
 proc tkcon_puts args {
     set len [llength $args]
     foreach {arg1 arg2 arg3} $args { break }
 
     if {$len == 1} {
-	tkcon console insert output "$arg1\n" stdout
+	set sarg $arg1
+	set nl   1
+	set farg stdout
     } elseif {$len == 2} {
 	if {![string compare $arg1 -nonewline]} {
-	    tkcon console insert output $arg2 stdout
+	    set sarg $arg2
+	    set farg stdout
+	    set nl 0
 	} elseif {![string compare $arg1 stdout] \
 		|| ![string compare $arg1 stderr]} {
-	    tkcon console insert output "$arg2\n" $arg1
+	    set sarg $arg2
+	    set farg $arg1
+	    set nl 1
 	} else {
 	    set len 0
 	}
@@ -2812,11 +2813,15 @@ proc tkcon_puts args {
 	if {![string compare $arg1 -nonewline] \
 		&& (![string compare $arg2 stdout] \
 		|| ![string compare $arg2 stderr])} {
-	    tkcon console insert output $arg3 $arg2
+	    set sarg $arg3
+	    set farg $arg2
+	    set nl 0
 	} elseif {(![string compare $arg1 stdout] \
 		|| ![string compare $arg1 stderr]) \
 		&& ![string compare $arg3 nonewline]} {
-	    tkcon console insert output $arg2 $arg1
+	    set sarg $arg2
+	    set farg $arg1
+	    set nl 0
 	} else {
 	    set len 0
 	}
@@ -2826,7 +2831,42 @@ proc tkcon_puts args {
 
     ## $len == 0 means it wasn't handled by tkcon above.
     ##
-    if {$len == 0} {
+
+    if {$len != 0} {
+
+	## "poor man's" \r substitution---erase everything on the output
+	## line and print from character after the \r
+
+	set rpt [string last \r $sarg]
+	if {$rpt >= 0} {
+	    tkcon console delete "insert linestart" "insert lineend"
+	    set sarg [string range $sarg [expr {$rpt + 1}] end]
+	}
+
+	set bpt [string first \b $sarg]
+	if {$bpt >= 0} {
+	    set narg [string range $sarg [expr {$bpt + 1}] end]
+	    set sarg [string range $sarg 0 [expr {$bpt - 1}]]
+	    set nl 0
+	}
+
+
+	if {$nl == 0} {
+	    tkcon console insert output $sarg $farg
+	} else {
+	    tkcon console insert output "$sarg\n" $farg
+	}
+
+	if {$bpt >= 0} {
+	    tkcon console delete "insert -1 char" insert
+	    if {$nl == 0} {
+		tkcon_puts $farg $narg nonewline
+	    } else {
+		tkcon_puts $farg $narg
+	    }
+	}
+
+    } else {
 	global errorCode errorInfo
 	if {[catch "tkcon_tcl_puts $args" msg]} {
 	    regsub tkcon_tcl_puts $msg puts msg
@@ -2849,7 +2889,7 @@ proc tkcon_puts args {
 ## This allows me to capture all stdin input without needing to stdin
 ## This will be renamed to 'gets' at the appropriate time during init
 ##
-# ARGS:		same as gets	
+# ARGS:		same as gets
 # Outputs:	same as gets
 ##
 proc tkcon_gets args {
@@ -2873,12 +2913,12 @@ proc tkcon_gets args {
 }
 
 ## edit - opens a file/proc/var for reading/editing
-## 
+##
 # Arguments:
 #   type	proc/file/var
 #   what	the actual name of the item
 # Returns:	nothing
-## 
+##
 proc edit {args} {
     array set opts {-find {} -type {} -attach {}}
     while {[string match -* [lindex $args 0]]} {
@@ -3030,7 +3070,7 @@ proc echo args { puts [concat $args] }
 
 ## clear - clears the buffer of the console (not the history though)
 ## This is executed in the parent interpreter
-## 
+##
 proc clear {{pcnt 100}} {
     if {![regexp {^[0-9]*$} $pcnt] || $pcnt < 1 || $pcnt > 100} {
 	return -code error \
@@ -3048,7 +3088,7 @@ proc clear {{pcnt 100}} {
 ## If called with one arg, returns the alias of that arg (or {} if none)
 # ARGS:	newcmd	- (optional) command to bind alias to
 # 	args	- command and args being aliased
-## 
+##
 proc alias {{newcmd {}} args} {
     if {[string match {} $newcmd]} {
 	set res {}
@@ -3065,7 +3105,7 @@ proc alias {{newcmd {}} args} {
 
 ## unalias - unaliases an alias'ed command
 # ARGS:	cmd	- command to unbind as an alias
-## 
+##
 proc unalias {cmd} {
     interp alias {} $cmd {}
 }
@@ -3085,7 +3125,7 @@ proc unalias {cmd} {
 #	--	forcibly ends options recognition
 #
 # Returns:	the values of the requested items in a 'source'able form
-## 
+##
 proc dump {type args} {
     set whine 1
     set code  ok
@@ -3637,13 +3677,13 @@ proc observe_var {name el op} {
 ## which - tells you where a command is found
 # ARGS:	cmd	- command name
 # Returns:	where command is found (internal / external / unknown)
-## 
+##
 proc which cmd {
     ## This tries to auto-load a command if not recognized
     set types [uplevel 1 [list what $cmd 1]]
     if {[llength $types]} {
 	set out {}
-	
+
 	foreach type $types {
 	    switch -- $type {
 		alias		{ set res "$cmd: aliased to [alias $cmd]" }
@@ -3674,7 +3714,7 @@ proc which cmd {
 ## what - tells you what a string is recognized as
 # ARGS:	str	- string to id
 # Returns:	id types of command as list
-## 
+##
 proc what {str {autoload 0}} {
     set types {}
     if {[llength [info commands $str]] || ($autoload && \
@@ -3721,7 +3761,7 @@ proc what {str {autoload 0}} {
 #	-long	- list in full format "permissions size date filename"
 #	-full	- displays / after directories and link paths for links
 # Returns:	a directory listing
-## 
+##
 proc dir {args} {
     array set s {
 	all 0 full 0 long 0
@@ -4106,7 +4146,7 @@ proc ::tkcon::Bindings {} {
     global tcl_platform tk_version
 
     #-----------------------------------------------------------------------
-    # Elements of tkPriv that are used in this file:
+    # Elements of ::tk::Priv that are used in this file:
     #
     # char -		Character position on the line;  kept in order
     #			to allow moving up or down past short lines while
@@ -4131,9 +4171,12 @@ proc ::tkcon::Bindings {} {
     }
 
     ## Get all Text bindings into TkConsole
-    foreach ev [bind Text] { bind TkConsole $ev [bind Text $ev] }	
+    foreach ev [bind Text] { bind TkConsole $ev [bind Text $ev] }
     ## We really didn't want the newline insertion
     bind TkConsole <Control-Key-o> {}
+
+    ## in 8.6b3, the virtual events <<NextLine>> and <<PrevLine>>
+    #  mess up our history feature
     bind TkConsole <<NextLine>> {}
     bind TkConsole <<PrevLine>> {}
 
@@ -4342,9 +4385,9 @@ proc ::tkcon::Bindings {} {
 
     bind TkConsole <Control-a> {
 	if {[%W compare {limit linestart} == {insert linestart}]} {
-	    tkTextSetCursor %W limit
+	    ::tk::TextSetCursor %W limit
 	} else {
-	    tkTextSetCursor %W {insert linestart}
+	    ::tk::TextSetCursor %W {insert linestart}
 	}
     }
     bind TkConsole <Key-Home> [bind TkConsole <Control-a>]
@@ -4368,14 +4411,14 @@ proc ::tkcon::Bindings {} {
     }
     bind TkConsole <<TkCon_Previous>> {
 	if {[%W compare {insert linestart} != {limit linestart}]} {
-	    tkTextSetCursor %W [tkTextUpDownLine %W -1]
+	    ::tk::TextSetCursor %W [::tk::TextUpDownLine %W -1]
 	} else {
 	    ::tkcon::Event -1
 	}
     }
     bind TkConsole <<TkCon_Next>> {
 	if {[%W compare {insert linestart} != {end-1c linestart}]} {
-	    tkTextSetCursor %W [tkTextUpDownLine %W 1]
+	    ::tk::TextSetCursor %W [::tk::TextUpDownLine %W 1]
 	} else {
 	    ::tkcon::Event 1
 	}
@@ -4390,7 +4433,7 @@ proc ::tkcon::Bindings {} {
     }
     bind TkConsole <<TkCon_Transpose>>	{
 	## Transpose current and previous chars
-	if {[%W compare insert > "limit+1c"]} { tkTextTranspose %W }
+	if {[%W compare insert > "limit+1c"]} { ::tk::TextTranspose %W }
     }
     bind TkConsole <<TkCon_ClearLine>> {
 	## Clear command line (Unix shell staple)
@@ -4408,10 +4451,10 @@ proc ::tkcon::Bindings {} {
 	::tkcon::Insert %W $::tkcon::PRIV(tmp)
 	%W see end
     }
-    catch {bind TkConsole <Key-Page_Up>   { tkTextScrollPages %W -1 }}
+    catch {bind TkConsole <Key-Page_Up>   { ::tk::TextScrollPages %W -1 }}
-    catch {bind TkConsole <Key-Prior>     { tkTextScrollPages %W -1 }}
+    catch {bind TkConsole <Key-Prior>     { ::tk::TextScrollPages %W -1 }}
-    catch {bind TkConsole <Key-Page_Down> { tkTextScrollPages %W 1 }}
+    catch {bind TkConsole <Key-Page_Down> { ::tk::TextScrollPages %W 1 }}
-    catch {bind TkConsole <Key-Next>      { tkTextScrollPages %W 1 }}
+    catch {bind TkConsole <Key-Next>      { ::tk::TextScrollPages %W 1 }}
     bind TkConsole <$PRIV(meta)-d> {
 	if {[%W compare insert >= limit]} {
 	    %W delete insert {insert wordend}
@@ -4429,7 +4472,7 @@ proc ::tkcon::Bindings {} {
     }
     bind TkConsole <ButtonRelease-2> {
 	if {
-	    (!$tkPriv(mouseMoved) || $tk_strictMotif) &&
+	    (!$::tk::Priv(mouseMoved) || $tk_strictMotif) &&
 	    ![catch {::tkcon::GetSelection %W} ::tkcon::PRIV(tmp)]
 	} {
 	    if {[%W compare @%x,%y < limit]} {
@@ -4600,7 +4643,7 @@ proc ::tkcon::TagProc w {
 # 	c1	- first char of pair
 # 	c2	- second char of pair
 # Calls:	::tkcon::Blink
-## 
+##
 proc ::tkcon::MatchPair {w c1 c2 {lim 1.0}} {
     if {[string compare {} [set ix [$w search -back $c1 insert $lim]]]} {
 	while {
@@ -4638,7 +4681,7 @@ proc ::tkcon::MatchPair {w c1 c2 {lim 1.0}} {
 ## The quote to match is assumed to be at the text index 'insert'.
 # ARGS:	w	- console text widget
 # Calls:	::tkcon::Blink
-## 
+##
 proc ::tkcon::MatchQuote {w {lim 1.0}} {
     set i insert-1c
     set j 0
@@ -4664,7 +4707,7 @@ proc ::tkcon::MatchQuote {w {lim 1.0}} {
 # 	i2	- end index of blink region
 # 	dur	- duration in usecs to blink for
 # Outputs:	blinks selected characters in $w
-## 
+##
 proc ::tkcon::Blink {w args} {
     eval [list $w tag add blink] $args
     after $::tkcon::OPT(blinktime) [list $w] tag remove blink $args
@@ -4679,7 +4722,7 @@ proc ::tkcon::Blink {w args} {
 # ARGS:	w	- text window in which to insert the string
 # 	s	- string to insert (usually just a single char)
 # Outputs:	$s to text widget
-## 
+##
 proc ::tkcon::Insert {w s} {
     if {[string match {} $s] || [string match disabled [$w cget -state]]} {
 	return
@@ -4695,7 +4738,7 @@ proc ::tkcon::Insert {w s} {
     $w see insert
 }
 
-## ::tkcon::Expand - 
+## ::tkcon::Expand -
 # ARGS:	w	- text widget in which to expand str
 # 	type	- type of expansion (path / proc / variable)
 # Calls:	::tkcon::Expand(Pathname|Procname|Variable)
@@ -4704,7 +4747,7 @@ proc ::tkcon::Insert {w s} {
 #		match equaled the string to expand, then all possible matches
 #		are output to stdout.  Triggers bell if no matches are found.
 # Returns:	number of matches found
-## 
+##
 proc ::tkcon::Expand {w {type ""}} {
     set exp "\[^\\\\\]\[\[ \t\n\r\\\{\"$\]"
     set tmp [$w search -backwards -regexp $exp insert-1c limit-1c]
@@ -4743,7 +4786,7 @@ proc ::tkcon::Expand {w {type ""}} {
 # Calls:	::tkcon::ExpandBestMatch
 # Returns:	list containing longest unique match followed by all the
 #		possible further matches
-## 
+##
 proc ::tkcon::ExpandPathname str {
     set pwd [EvalAttached pwd]
     # Cause a string like {C:/Program\ Files/} to become "C:/Program Files/"
@@ -4825,7 +4868,7 @@ proc ::tkcon::ExpandProcname str {
 # Calls:	::tkcon::ExpandBestMatch
 # Returns:	list containing longest unique match followed by all the
 #		possible further matches
-## 
+##
 proc ::tkcon::ExpandVariable str {
     if {[regexp {([^\(]*)\((.*)} $str junk ary str]} {
 	## Looks like they're trying to expand an array.
@@ -4853,7 +4896,7 @@ proc ::tkcon::ExpandVariable str {
 ## or $e is {}.  $e is extra for compatibility with proc below.
 # ARGS:	l	- list to find best unique match in
 # Returns:	longest unique match in the list
-## 
+##
 proc ::tkcon::ExpandBestMatch2 {l {e {}}} {
     set s [lindex $l 0]
     if {[llength $l]>1} {
@@ -4873,7 +4916,7 @@ proc ::tkcon::ExpandBestMatch2 {l {e {}}} {
 # ARGS:	l	- list to find best unique match in
 # 	e	- currently best known unique match
 # Returns:	longest unique match in the list
-## 
+##
 proc ::tkcon::ExpandBestMatch {l {e {}}} {
     set ec [lindex $l 0]
     if {[llength $l]>1} {
@@ -5237,7 +5280,7 @@ proc ::tkcon::Retrieve {} {
 ## ::tkcon::Resource - re'source's this script into current console
 ## Meant primarily for my development of this program.  It follows
 ## links until the ultimate source is found.
-## 
+##
 set ::tkcon::PRIV(SCRIPT) [info script]
 if {!$::tkcon::PRIV(WWW) && [string compare $::tkcon::PRIV(SCRIPT) {}]} {
     # we use a catch here because some wrap apps choke on 'file type'