| blob | 108c25db22410ed703ab310b57e2bb1913d834b4 |
1 /*----------------------------------------------------------------------*/
2 /* netlist.c --- xcircuit routines specific to schematic capture and */
3 /* netlist generation */
4 /*----------------------------------------------------------------------*/
5 /* Copyright (c) 2004 Tim Edwards, Johns Hopkins University, */
6 /* MultiGiG, Inc., and Open Circuit Design, Inc. */
7 /* Copyright (c) 2005 Tim Edwards, MultiGiG, Inc. */
8 /* */
9 /* Written April 1998 to January 2004 */
10 /* Original version for Pcb netlisting 3/20/98 by Chow Seong Hwai, */
11 /* Leeds University, U.K. */
12 /* */
13 /* Greatly modified 4/2/04 to handle bus notation; net identifier */
14 /* changed from a listing by net to two listings, by polygon and by */
15 /* label, with nets and subnets identifiers attached to each element, */
16 /* rather than vice versa. */
17 /*----------------------------------------------------------------------*/
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <ctype.h>
25 #include <sys/stat.h>
26 #ifndef _MSC_VER
27 #include <unistd.h>
28 #endif
30 #ifdef HAVE_PYTHON
31 #include <Python.h>
32 #endif
34 #ifndef _MSC_VER
35 #include <X11/Intrinsic.h>
36 #include <X11/StringDefs.h>
37 #endif
39 #ifdef TCL_WRAPPER
40 #include <tk.h>
41 #endif
43 /*----------------------------------------------------------------------*/
44 /* Local includes */
45 /*----------------------------------------------------------------------*/
50 /*----------------------------------------------------------------------*/
51 /* Function prototype declarations */
52 /*----------------------------------------------------------------------*/
55 #ifdef HAVE_PYTHON
57 #endif
58 #ifdef TCL_WRAPPER
61 #endif
63 /*----------------------------------------------------------------------*/
64 /* Externally declared global variables */
65 /*----------------------------------------------------------------------*/
69 /*----------------------------------------------------------------------*/
79 LabellistPtr global_labels;
85 u_int index;
86 fidxptr next;
95 #define EndPoint(n) (((n == 1) ? 1 : (int)(n - 1)))
96 #define NextPoint(n) (((n == 1) ? 0 : 1))
98 /* For bus matching: whether to match by number of nets, by */
99 /* exact match of sub-bus numbers, or an exact match of net IDs. */
101 #define MATCH_EXACT 0
102 #define MATCH_SUBNETS 1
103 #define MATCH_SIZE 2
104 #define MATCH_OVERLAP 3
106 /*----------------------------------------------------------------------*/
107 /* Check whether two line segments attach to or cross each other */
108 /* Return 1 if attached, 0 if not (INLINE code) */
109 /* int onsegment(XPoint *a, XPoint *b, XPoint *x) {} */
110 /*----------------------------------------------------------------------*/
113 #define onsegment(a, b, x) (finddist(a, b, x) <= ONDIST)
115 /*--------------------------------------------------------------*/
116 /* d36a: Base 36 to string conversion */
117 /*--------------------------------------------------------------*/
120 {
132 }
134 }
136 /*--------------------------------------------------------------*/
137 /* Translate a pin name to a position relative to an object's */
138 /* point of origin. This is used by the ASG module to find */
139 /* the placement of pins based on names from a netlist. */
140 /* */
141 /* returns 0 on success and fills x_ret and y_ret with the */
142 /* pin position coordinates. Returns -1 if the pin name did */
143 /* not match any label names in the object. */
144 /*--------------------------------------------------------------*/
147 {
150 labelptr plab;
163 }
164 }
165 }
166 }
168 }
170 /*--------------------------------------------------------------*/
171 /* Translate a point position back to the calling object's */
172 /* coordinate system. */
173 /* Original value is passed in "thispoint"; Translated value */
174 /* is put in "refpoint". */
175 /*--------------------------------------------------------------*/
178 {
179 /* objectptr thisobj = thisinst->thisobject; (jdk) */
180 Matrix locctm;
182 /* Translate pin position back to originating object */
188 }
190 /*--------------------------------------------------------------*/
191 /* Variant of NameToPinLocation(): Given a port number, find */
192 /* the pin associated with that port. */
193 /*--------------------------------------------------------------*/
196 {
197 labelptr plab;
199 PortlistPtr ports;
203 else
210 }
211 }
213 }
215 /*--------------------------------------------------------------*/
216 /* This function is the same as PortToLocalPosition() but */
217 /* returns the point in the coordinate system of the parent. */
218 /*--------------------------------------------------------------*/
221 {
227 }
229 /*----------------------------------------------------------------------*/
230 /* Get the hierarchy of the page stack and return as a string */
231 /*----------------------------------------------------------------------*/
234 Boolean canonical)
235 {
237 CalllistPtr calls;
238 /* char numstr[12]; (jdk) */
244 /* Recurse so we build up the prefix string from top down */
248 }
257 /* Top level is a fundamental symbol */
259 }
263 }
264 }
265 }
269 /* When we have "traveled" through both a symbol and its */
270 /* associated schematic, only append the prefix for the */
271 /* first one encountered. */
273 /*
274 if (thisobj->symschem != NULL && stack->next != NULL &&
275 thisobj->symschem == stack->next->thisinst->thisobject)
276 return True;
277 */
283 /* Check for resolved device indices and generate them if necessary */
291 }
293 /* Add this level of the hierarchy to the prefix string */
304 }
308 }
313 else
319 }
320 }
322 }
324 /*----------------------------------------------------------------------*/
327 {
334 }
341 }
343 /*----------------------------------------------------------------------*/
344 /* Invalidate a netlist. The invalidation must be referred to the */
345 /* master schematic, if the object is a secondary schematic. */
346 /*----------------------------------------------------------------------*/
349 {
353 else
355 }
356 }
358 /*--------------------------------------------------------------*/
359 /* Check if the selected items are relevant to the netlist. */
360 /* Only invalidate the current netlist if they are. */
361 /*--------------------------------------------------------------*/
364 {
383 }
384 }
386 }
388 /*------------------------------------------------------------------*/
389 /* Check proximity of two points (within roundoff tolerance ONDIST) */
390 /*------------------------------------------------------------------*/
393 {
401 }
403 /*----------------------------------------------------------------------*/
404 /* createnets(): Generate netlist structures */
405 /* */
406 /* Result is the creation of three linked lists inside each object in */
407 /* the circuit hierarchy: */
408 /* */
409 /* 1) the netlist: assigns a number to each network of polygons and */
410 /* pin labels on the object. */
411 /* 2) the ports: a list of every network which is connected from */
412 /* objects above this one in the hierarchy. */
413 /* 3) the calls: a list of calls made from the object to all sub- */
414 /* circuits. Each calls indicates the object and/or */
415 /* instance being called, and a port list which must match */
416 /* the ports of the object being called (the port lists */
417 /* are not reflexive, as the caller does not have to call */
418 /* all of the instance's ports, but the instance must have */
419 /* a port defined for every connection being called). */
420 /* (see structure definitions in xcircuit.h). */
421 /*----------------------------------------------------------------------*/
424 {
429 /* New in 3.3.32: Generating a netlist from a symbol is */
430 /* okay if the symbol has an associated netlist. */
438 }
439 }
447 /* Wprintf("Finished netlists"); */
449 }
451 /*----------------------------------------------------------------------*/
452 /* Free all memory associated with the netlists. */
453 /*----------------------------------------------------------------------*/
456 {
457 objectptr pschem;
460 thisobject;
465 }
467 /*----------------------------------------------------------------------*/
468 /* Polygon types which are ignored when considering if a polygon */
469 /* belongs to a circuit network: */
470 /* Closed polygons (boxes) */
471 /* Bounding box polygons */
472 /* Filled polygons */
473 /* Dashed and dotted line-style polygons */
474 /*----------------------------------------------------------------------*/
477 {
482 }
484 /*----------------------------------------------------------------------*/
485 /* Return the largest (most negative) net number in the global netlist */
486 /*----------------------------------------------------------------------*/
489 {
490 LabellistPtr gl;
499 }
506 }
507 }
508 }
510 }
512 /*----------------------------------------------------------------------*/
513 /* Return the largest net number in an object's netlist */
514 /*----------------------------------------------------------------------*/
517 {
518 PolylistPtr gp;
519 LabellistPtr gl;
528 }
535 }
536 }
537 }
542 }
549 }
550 }
551 }
553 }
555 /*----------------------------------------------------------------------*/
556 /* Resolve nets and pins for the indicated object */
557 /* */
558 /* When encountering object instances, call gennetlist() on the object */
559 /* if it does not have a valid netlist, then recursively call */
560 /* gennetlist(). Ignore "info" labels, which are not part of the */
561 /* network. */
562 /* */
563 /*----------------------------------------------------------------------*/
566 {
574 Boolean visited;
579 PolylistPtr plist;
580 LabellistPtr lseek;
586 /* Determine the type of object being netlisted */
592 /* Has this object been visited before? */
599 /* Make sure that schematics are netlisted before their symbols */
607 }
608 else
610 }
612 /* Sanity check on symbols with schematics: Are there any pins? */
620 }
621 }
623 /* Don't warn if schematic has infolabels */
626 }
628 /* If this is a secondary schematic, run on the primary (master) */
630 thisobject;
634 /* We start the loop for schematics but will modify the loop */
635 /* variable to execute just once in the case of a symbol. */
636 /* It's just not worth the trouble to turn this into a */
637 /* separate subroutine. . . */
644 }
652 }
654 /* Determine the existing number of parts. We do not want to */
655 /* search over elements that we create in this routine. */
659 /* Part 1: Recursion */
660 /* Schematic pages and symbols acting as their own schematics are the */
661 /* two types on which we recurse to find all sub-schematics. */
679 }
680 else
682 }
686 }
688 /* object on its own schematic */
693 /* Also generate netlist for pins in the corresponding symbol */
696 }
697 }
698 }
700 /* Part 2: Match pin labels to nets, and add to list of globals */
701 /* if appropriate. We do all pins first, before ennumerating */
702 /* polygons, so that buses can be handled correctly, generating */
703 /* overlapping subnets. */
711 /* Check if the label has a non-default parameter. */
712 /* If so, we want to record the instance along */
713 /* the other netlist information about the pin. */
721 }
723 /* If we have netlisted this object before, and the */
724 /* label is already in the netlist, then ignore it. */
725 /* This only happens for labels without instanced */
726 /* parameter values. */
733 }
736 else
737 /* Note any overlapping labels. */
742 /* For symbols: Check that this pin has a */
743 /* corresponding pin in the schematic. The schematic */
744 /* is netlisted before the symbol, so the netlist */
745 /* should be there. */
749 /* There is always the possibility that the symbol */
750 /* pin does not correspond to anything in the */
751 /* schematic. If so, it gets its own unique net */
752 /* number. HOWEVER, this situation usually indicates */
753 /* an error in the schematic, so output a warning */
754 /* message. */
766 }
767 }
769 /* For schematics: Relate the pin to a network */
772 /* If only part of a bus has been identified, generate */
773 /* the net ID's of the parts that haven't been. */
780 }
781 }
782 }
789 }
799 }
803 }
804 }
808 }
809 }
810 }
815 }
820 }
821 }
823 /* Note the presence of info labels in the */
824 /* subcircuit, indicating that it needs to be */
825 /* called because it will generate output. */
827 }
828 }
829 }
831 /* Part 3: Polygon enumeration */
832 /* Assign network numbers to all polygons in the object. */
833 /* (Ignore symbols, as we only consider pins on symbols) */
834 /* Where multiple pins occur at a point (bus notation), */
835 /* polygons will be duplicated in each network. */
846 /* Ignore non-network (closed, bbox, filled) polygons */
851 /* Check for attachment of each segment of this polygon */
852 /* to position of every recorded pin label. */
868 }
872 }
873 }
874 }
875 /* if we've encountered a unique instance, then con- */
876 /* tinue past all other instances using this label. */
880 }
882 /* Check for attachment of each segment of this polygon */
883 /* to endpoints of every recorded network polygon. */
899 /* Nets previously counted distinct have */
900 /* been connected together by this polygon. */
904 }
908 }
909 }
910 }
912 /* Check for attachment of the endpoints of this polygon */
913 /* to each segment of every recorded network polygon. */
924 /* Nets previously counted distinct have */
925 /* been connected together by this polygon. */
929 }
933 }
934 }
935 }
936 }
939 /* This polygon belongs to an unvisited */
940 /* network. Give this polygon a new net */
941 /* number and add to the net list. */
945 }
946 }
947 }
948 }
949 }
950 }
952 /*--------------------------------------------------------------*/
953 /* Search a sibling of object instance "cinst" for connections */
954 /* between the two. Recurse through the schematic hierarchy of */
955 /* the sibling object. */
956 /*--------------------------------------------------------------*/
960 {
963 labelptr olabel;
964 polyptr tpoly;
965 PolylistPtr pseek;
966 LabellistPtr lseek;
969 objinstptr subsibinst;
975 /* If the sibling is a symbol or fundamental or trivial object, then */
976 /* we just look at pin labels from the parts list and return. */
987 /* Transform all the way up to the level above cinst */
992 }
994 }
995 }
997 /* If the sibling is a schematic, we look at connections to pins and */
998 /* polygons, and recursively search subschematics of the sibling. */
1002 /* Look for pins connecting to pins in the object */
1010 /* Transform all the way up to the level above cinst */
1015 }
1017 }
1019 /* Look for polygon ends connecting into the object */
1027 /* Transform all the way up to the level above cinst */
1032 }
1034 }
1036 /* Recursively search all schematic children of the sibling */
1042 /* objinstptr iinst = (objinstptr)iseek; (jdk) */
1044 /* Don't search this instance unless the bounding box */
1045 /* overlaps the bounding box of the calling object. */
1052 }
1059 /* push stack */
1067 /* pop stack */
1072 }
1073 }
1074 }
1076 }
1078 /*--------------------------------------------------------------*/
1079 /* Generate ports from pin labels for all objects: */
1080 /* For each pin-label in the subcircuit or symbol, generate */
1081 /* a port in the object or instance's object. */
1082 /* Translate the pin position to the level above and search */
1083 /* for & link in any connecting nets. */
1084 /* */
1085 /* Generate calls to object instances. */
1086 /* Pick up any other nets which might be formed by */
1087 /* juxtaposition of object instances on different levels of the */
1088 /* schematic hierarchy (e.g., pin-to-pin connections). */
1089 /*--------------------------------------------------------------*/
1092 {
1094 Matrix locctm;
1097 XPoint xpos;
1100 /* buslist *sbus; (jdk) */
1101 labelptr olabel;
1102 polyptr tpoly;
1103 PolylistPtr pseek;
1104 /* CalllistPtr cseek; (jdk) */
1105 LabellistPtr lseek;
1108 /* The netlist is always kept in the master schematic */
1110 thisobject;
1115 /* We start the loop for schematics but will modify the loop */
1116 /* variable to execute just once in the case of a symbol. */
1117 /* (see gennetlist(), where the same thing is done) */
1123 }
1131 }
1138 /* Determine where the hierarchy continues downward */
1142 else
1145 /* Ignore any object on its own schematic */
1151 /* Note: callobj is the next schematic in the hierarchy. */
1152 /* callsymb is the next visible object in the hierarchy, */
1153 /* which may be either a schematic or a symbol. */
1155 /*-------------------------------------------------------------*/
1156 /* For object instances which are their own schematics (i.e., */
1157 /* have netlist elements), don't rely on any pin list but make */
1158 /* a survey of how polygons connect into the object. */
1159 /*-------------------------------------------------------------*/
1165 /* Fprintf(stdout, "*** Analyzing connections from %s"
1166 " to instance of %s\n", cschem->name,
1167 callinst->thisobject->name); */
1169 /* Look for pins connecting to pins in the object */
1177 /* if we've encountered a unique instance, then con- */
1178 /* tinue past all other instances using this label. */
1182 }
1184 /* Look for polygon ends connecting into the object */
1190 }
1192 /* For each call to a schematic or symbol which is NOT the */
1193 /* one under consideration, see if it touches or overlaps */
1194 /* the object under consideration. Search for connections */
1195 /* between the two objects. */
1199 /* Only need to look forward from the current position. */
1206 /* Check intersection of the two object instances; */
1207 /* don't do a search if they are disjoint. */
1214 }
1215 }
1216 }
1217 }
1219 /*----------------------------------------------------------*/
1220 /* Recursively call gencalls() on the schematic. */
1221 /*----------------------------------------------------------*/
1226 /*----------------------------------------------------------*/
1227 /* Create a call to the object callsymb from object cschem */
1228 /*----------------------------------------------------------*/
1232 /*----------------------------------------------------------*/
1233 /* Search again on symbol pins to generate calls to ports. */
1234 /*----------------------------------------------------------*/
1241 /* LabellistPtr slab; (jdk) */
1242 /* labelptr slabel; (jdk) */
1251 /* Translate pin position back to object cschem */
1254 /* What net in the calling object connects to this point? */
1257 /* If there's no net, we make one */
1261 /* Generate a port call for a global signal if the */
1262 /* global label appears in the symbol (9/29/04). This */
1263 /* is a change from previous behavior, which was to not */
1264 /* make the call. */
1269 /* Attempt to generate a port in the object. */
1272 /* Generate the call to the port */
1275 // If object is "dot" then copy the bus from the
1276 // net to the dot. The dot takes on whatever
1277 // dimension the bus is.
1281 }
1287 }
1288 }
1290 /* if we've encountered a unique instance, then continue */
1291 /* past all other instances using this label. */
1295 }
1297 /*----------------------------------------------------------*/
1298 /* If after all that, no ports were called, then remove the */
1299 /* call to this object instance. However, we should check */
1300 /* for info labels, because the device may produce output */
1301 /* for the netlist even if it has no declared ports. This */
1302 /* is irrespective of the presence of pin labels---if the */
1303 /* symbol is "trivial", the netlist connections are */
1304 /* resolved in the level of the hierarchy above, and there */
1305 /* may be no ports, but the call list must retain the call */
1306 /* to ensure that the netlist output is generated. */
1307 /*----------------------------------------------------------*/
1312 }
1313 }
1314 }
1315 }
1317 /*----------------------------------------------------------------------*/
1318 /* Translate a net number down in the calling hierarchy */
1319 /*----------------------------------------------------------------------*/
1322 {
1323 PortlistPtr nport;
1330 }
1331 }
1333 }
1335 /*----------------------------------------------------------------------*/
1336 /* Translate a netlist up in the calling hierarchy */
1337 /* */
1338 /* This routine creates a new netlist header which needs to be freed */
1339 /* by the calling routine. */
1340 /* */
1341 /* Note that if the entire netlist cannot be translated up, then the */
1342 /* routine returns NULL. This could be modified to return the part of */
1343 /* the network that can be translated up. */
1344 /*----------------------------------------------------------------------*/
1348 {
1349 PortlistPtr nport;
1350 CalllistPtr ccall;
1368 }
1373 }
1374 }
1383 }
1384 }
1386 }
1387 }
1391 }
1395 }
1400 }
1401 }
1403 }
1405 }
1407 /*----------------------------------------------------------------------*/
1408 /* Check whether the indicated polygon is already resolved into the */
1409 /* netlist of the object hierarchy described by seltop. */
1410 /* Return the netlist if resolved, NULL otherwise. The netlist */
1411 /* returned is referred (translated) upward through the calling */
1412 /* hierarchy to the topmost object containing that net or those nets. */
1413 /* This topmost object is returned in parameter topobj. */
1414 /* Note that the netlist returned does not necessarily correspond to */
1415 /* any object in the top level. It is allocated and must be freed by */
1416 /* the calling routine. */
1417 /*----------------------------------------------------------------------*/
1420 {
1422 objectptr pschem;
1423 PolylistPtr pseek;
1424 LabellistPtr lseek;
1429 /* Recursively call self, since we have to back out from the bottom of */
1430 /* the stack. */
1435 /* Translate network ID up the hierarchy to the topmost object in which */
1436 /* the network exists. */
1442 /* Net does not exist upwards of this object. Pass net ID */
1443 /* upward with "topobj" unchanged. */
1448 }
1449 }
1450 }
1453 /* Find the net ID for the listed object, which should be in the object */
1454 /* on the bottom of the pushlist stack. */
1461 }
1462 }
1463 }
1469 }
1470 }
1471 }
1474 /* Make a copy of the netlist header from this element */
1479 }
1480 }
1482 /* done: (jdk) */
1485 }
1487 /*--------------------------------------------------------------*/
1488 /* Highlight all the polygons and pin labels in a network */
1489 /* (recursively, downward). Pin labels are drawn only on the */
1490 /* topmost schematic object. */
1491 /* Returns true if some part of the hierarchy declared a net to */
1492 /* be highlighted. */
1493 /* mode = 1 highlight, mode = 0 erase */
1494 /*--------------------------------------------------------------*/
1497 {
1498 CalllistPtr calls;
1499 PortlistPtr ports;
1500 PolylistPtr plist;
1501 LabellistPtr llist;
1502 polyptr cpoly;
1503 labelptr clabel;
1504 objinstptr ccinst;
1508 objectptr pschem;
1520 else
1523 /* Fprintf(stdout, " >> Found polygon belonging to net %d at (%d, %d)\n",
1524 locnetid, cpoly->points[0].x, cpoly->points[0].y); */
1528 }
1531 }
1533 }
1534 }
1536 /* Highlight labels if they belong to the top-level object */
1546 else
1553 }
1554 else
1556 /* Fprintf(stdout, " >> Found label belonging to net "
1557 "%d at (%d, %d)\n",
1558 locnetid, clabel->position.x,
1559 clabel->position.y); */
1561 }
1563 }
1565 }
1566 /* if we've encountered a unique instance, then continue */
1567 /* past all other instances using this label. */
1571 }
1573 /* Highlight all pins connecting this net to symbols */
1575 }
1577 /* Connectivity recursion */
1585 /* Recurse only on objects for which network polygons are visible */
1586 /* from the calling object: i.e., non-trivial, non-fundamental */
1587 /* objects acting as their own schematics. */
1598 /* Fprintf(stdout, " > Calling object %s at (%d, %d)\n",
1599 calls->callobj->name, ccinst->position.x, ccinst->position.y); */
1600 /* Fprintf(stdout, " > Net translation from %d to %d (port %d)\n",
1601 netid, netto, ports->portid); */
1605 }
1607 /* Otherwise (symbols, fundamental, trivial, etc., objects), we */
1608 /* highlight the pin position of the port. */
1611 }
1613 }
1614 }
1615 }
1617 }
1619 /*----------------------------------------------------------------------*/
1620 /* Highlight whatever nets are listed in the current object instance, */
1621 /* if any. */
1622 /*----------------------------------------------------------------------*/
1625 {
1639 }
1642 }
1644 /* If we are erasing, remove the netlist entry from the object */
1649 }
1650 }
1652 /*----------------------------------------------------------------------*/
1653 /* Push the matrix stack for each object (instance) until the indicated */
1654 /* object is reached. This works similarly to highlightnet() above, */
1655 /* but makes calls according to the hierarchy described by the */
1656 /* pushlistptr parameter. */
1657 /* Returns the number of stack objects to pop after we're done. */
1658 /*----------------------------------------------------------------------*/
1661 {
1663 objinstptr sinst;
1671 rno++;
1672 }
1677 }
1680 }
1682 /*----------------------------------------------------------------------*/
1683 /* Determine if two netlists match. If "mode" is MATCH_EXACT, the */
1684 /* net numbers and subnet numbers must all be the same. If */
1685 /* MATCH_SUBNETS, then the subnet numbers must be the same. If */
1686 /* MATCH_SIZE, then they need only have the same number of subnets. */
1687 /*----------------------------------------------------------------------*/
1690 {
1695 // A wire (no subnets) matches a bus of 1 subnet. All others
1696 // are non-matching.
1702 }
1711 }
1713 }
1718 }
1723 /* A subnetid of < 0 indicates an unassigned bus */
1726 }
1734 }
1735 }
1737 }
1739 /*----------------------------------------------------------------------*/
1740 /* Copy the netlist structure from one netlist element to another */
1741 /*----------------------------------------------------------------------*/
1744 {
1761 }
1762 }
1763 }
1765 /*------------------------------------------------------*/
1766 /* Create a new "temporary" label object for a pin */
1767 /* This type of label is never drawn, so it doesn't */
1768 /* need font info. It is identified as "temporary" by */
1769 /* this lack of a leading font record. */
1770 /*------------------------------------------------------*/
1774 {
1781 }
1792 }
1795 }
1797 /* Add label to object's netlist and return a pointer to the */
1798 /* netlist entry. */
1801 }
1803 /*------------------------------------------------------*/
1804 /* Create a label for use in the list of global nets. */
1805 /* This label is like a temporary label (new_tmp_pin) */
1806 /* except that it is not represented in any object. */
1807 /* The string contains the verbatim contents of any */
1808 /* parameter substitutions in the original label. */
1809 /*------------------------------------------------------*/
1812 {
1813 labelptr newlabel;
1823 /* Add label to the global netlist and return a pointer to */
1824 /* the netlist entry. */
1827 }
1829 /*----------------------------------------------------------------------*/
1830 /* Create a temporary I/O pin (becomes part of netlist and also part of */
1831 /* the object itself). */
1832 /*----------------------------------------------------------------------*/
1836 {
1837 LabellistPtr lseek;
1838 objectptr pschem;
1840 /* buslist *sbus; (jdk) */
1841 /* int lbus; (jdk) */
1847 /* Primary schematic (contains the netlist) */
1850 /* Determine a netlist for this pin */
1856 }
1858 /* If there is any other pin at this location, don't make another */
1859 /* one. If there is already a temporary pin associated with the */
1860 /* net, use its name. */
1872 }
1873 /* if we've encountered a unique instance, then continue past */
1874 /* all other instances using this label. */
1878 }
1879 }
1881 }
1883 /*--------------------------------------------------------------*/
1884 /* Search for connections into a non-symbol subcircuit, based */
1885 /* on various combinations of polygon and pin label overlaps. */
1886 /*--------------------------------------------------------------*/
1889 {
1891 objinstptr tinst;
1893 polyptr tpoly;
1894 labelptr tlab;
1896 LabellistPtr tseek;
1897 PolylistPtr pseek;
1901 /* Generate temporary polygon in the coordinate system of */
1902 /* the object instance in question */
1907 /* Fprintf(stdout, "Info: translated polygon w.r.t. object %s\n", */
1908 /* cinst->thisobject->name); */
1910 /* Recursion on all appropriate sub-schematics. */
1911 /* (Use parts list, not call list, as call list may not have created yet) */
1921 }
1922 }
1923 }
1932 /* Look at the object only (symbol, or schematic if it has no symbol) */
1935 /* Search for connections to pin labels */
1942 /* Fprintf(stdout, "%s connects to pin %s of %s in %s\n", */
1943 /* ((number > 1) ? "Polygon" : "Pin"), */
1944 /* tlab->string + 2, tinst->thisobject->name, */
1945 /* cinst->thisobject->name); */
1949 }
1950 }
1951 }
1956 /* Search for connections from segments passed to this */
1957 /* function to endpoints of polygons in the netlist. */
1965 /* Create new pinlabel (only if there is not one already there) */
1970 }
1971 }
1972 }
1977 /* Search for connections from endpoints passed to this */
1978 /* function to segments of polygons in the netlist. */
1991 /* Create new pinlabel (only if there is not one already there) */
1996 }
1997 }
1998 }
2001 }
2003 /*----------------------------------------------------------------------*/
2004 /* Associate polygon with given netlist and add to the object's list */
2005 /* of network polygons (i.e., wires). */
2006 /*----------------------------------------------------------------------*/
2009 {
2010 PolylistPtr newpoly;
2011 objectptr pschem;
2012 /* buslist *sbus; (jdk) */
2013 /* int lbus, sub_bus; (jdk) */
2015 /* Netlist is in the master schematic */
2018 /* If this polygon is already in the list, then add an extra subnet */
2019 /* if necessary. */
2026 }
2028 }
2029 }
2031 /* Create a new entry and link to polygon list of this object */
2042 }
2044 /*-------------------------------------------------------------------------*/
2047 {
2051 }
2053 /*----------------------------------------------------------------------*/
2054 /* Promote a single net to a bus. The bus size will be equal to the */
2055 /* value "subnets". */
2056 /*----------------------------------------------------------------------*/
2059 {
2061 CalllistPtr calls;
2062 PortlistPtr ports;
2063 PolylistPtr plist;
2064 LabellistPtr llist;
2067 Boolean foundlabel;
2069 /* If no promotion is required, don't do anything */
2072 /* It "netfrom" is already a bus, but of different size than */
2073 /* subnets, then it cannot be changed. */
2078 }
2082 /* If "subnets" is 1, then "netfrom" can be promoted regardless. */
2083 /* Otherwise, if the "netfrom" net is used in any calls, then it */
2084 /* cannot be promoted. */
2093 }
2095 }
2105 }
2107 }
2109 /* It's possible for a label without bus notation to be attached */
2110 /* to this net. */
2121 }
2124 }
2126 /* We need to create a temp label associated with this net to */
2127 /* encompass the promoted bus size. If this bus is later attached */
2128 /* to a known bus, that bus name will be canonical. If no bus name */
2129 /* is ever assigned to the bus, this temp one will be used. */
2135 }
2136 }
2138 /*----------------------------------------------------------------------*/
2139 /* Change any part of the netlist "testlist" that matches the net IDs */
2140 /* of "orignet" to the net IDs of "newnet". It is assumed that the */
2141 /* lengths and sub-bus numbers of "orignet" and "newnet" match. */
2142 /*----------------------------------------------------------------------*/
2146 {
2155 }
2160 }
2165 }
2170 }
2178 }
2180 /* Promote testlist to a bus subnet of size 1 */
2187 }
2188 }
2189 }
2192 /* If the sub-bus numbers match, then change the net */
2193 /* ID to the new net number. If the sub-bus is */
2194 /* unnamed (has no associated bus-notation label), */
2195 /* then it can take on the net and subnet numbers. */
2204 }
2210 /* Keep subnetid---but, does newnet need to be promoted? */
2212 }
2218 }
2219 }
2220 }
2221 }
2223 }
2225 }
2227 /*----------------------------------------------------------------------*/
2228 /* Combine two networks in an object's linked-list Netlist */
2229 /* Parameters: cschem - pointer to object containing netlist */
2230 /* orignet - original netlist to be changed */
2231 /* newnet - new netlist to be changed to */
2232 /* */
2233 /* Attempts to merge different subnets in a bus are thwarted. */
2234 /*----------------------------------------------------------------------*/
2237 {
2238 PolylistPtr plist;
2239 LabellistPtr llist;
2240 CalllistPtr calls;
2241 PortlistPtr ports;
2242 Genericlist savenet;
2245 Boolean rval;
2247 /* Trivial case; do nothing */
2250 /* Disallow an attempt to convert a global net to a local net: */
2251 /* The global net ID always dominates! */
2258 }
2260 /* Check that the lists of changes are compatible. It appears to be */
2261 /* okay to have non-matching buses (although they should not be */
2262 /* merged), as this is a valid style in which buses do not have taps */
2263 /* but the sub-buses are explicitly called out with labels. In such */
2264 /* case, the polygons of different sub-buses touch, and this routine */
2265 /* rejects them as being incompatible. */
2269 labelptr nlab;
2270 /* If only the subnet numbers don't match up, check if */
2271 /* "orignet" has a temp label. */
2276 }
2277 }
2278 else
2281 }
2283 can_merge:
2285 /* If orignet is a bus size 1 and newnet is a wire, then promote */
2286 /* newnet to a bus size 1. */
2296 }
2298 /* Make a copy of the net so we don't overwrite it */
2313 /* Because nets that have been merged away may be re-used later, */
2314 /* change the name of any temporary labels to the new net number */
2324 }
2325 }
2326 }
2327 }
2331 /* Reflect the net change in the object's call list, if it has one. */
2338 }
2345 }
2346 }
2347 }
2348 }
2349 }
2351 /* Free the copy of the bus that we made, if we made one */
2355 }
2357 /*----------------------------------------------------------------------*/
2358 /* Wrapper to netmerge() to make sure change is made both to the symbol */
2359 /* and schematic, if both exist. */
2360 /*----------------------------------------------------------------------*/
2363 {
2364 Boolean merged;
2372 }
2374 /*----------------------------------------------------------------------*/
2375 /* Remove a call to an object instance from the call list of cschem */
2376 /*----------------------------------------------------------------------*/
2379 {
2383 /* find the instance call before this one and link it to the one following */
2390 }
2395 }
2399 else
2407 }
2409 }
2411 /*----------------------------------------------------------------------*/
2412 /* Add a pin label to the netlist */
2413 /* If cschem == NULL, add the pin to the list of global pins. */
2414 /* The new label entry in the netlist gets a copy of the netlist */
2415 /* "netlist". */
2416 /*----------------------------------------------------------------------*/
2420 {
2422 objectptr pschem;
2423 /* buslist *sbus; (jdk) */
2424 /* int lbus, sub_bus; (jdk) */
2434 }
2435 }
2439 }
2441 }
2443 /* Create a new entry and link to label list of the object */
2452 /* Always put the specific (instanced) cases in front of */
2453 /* generic cases for the same label. */
2455 /* Generic case---make it the last record for this label */
2460 }
2461 }
2465 }
2469 }
2471 }
2473 /*----------------------------------------------------------------------*/
2474 /* Add a pin label to the list of global net names. */
2475 /* The new label entry in the netlist gets a copy of the netlist */
2476 /* "netlist" and a copy of label "pin" containing the *instance* value */
2477 /* of the text. */
2478 /*----------------------------------------------------------------------*/
2482 {
2488 }
2496 }
2497 }
2501 }
2503 }
2505 /* Create a new entry and link to label list of the object */
2517 }
2521 }
2523 }
2525 /*----------------------------------------------------------------------*/
2526 /* Allocate memory for the new call list element */
2527 /* Define the values for the new call list element */
2528 /* Insert new call into call list */
2529 /* The new call is at the beginning of the list. */
2530 /*----------------------------------------------------------------------*/
2533 {
2534 CalllistPtr newcall;
2535 objectptr pschem;
2537 /* Netlist is on the master schematic */
2549 }
2551 /*----------------------------------------------------------------------*/
2552 /* Add a port to the object cschem which connects net "netto" to */
2553 /* the calling object. One port is created for each net ID in "netto" */
2554 /* (which may be a bus). The port contains the net ID in the called */
2555 /* object. The port may already exist, in which case this routine does */
2556 /* nothing. */
2557 /*----------------------------------------------------------------------*/
2560 {
2564 Boolean duplicate;
2573 }
2575 /* If a port already exists for this net, don't add another one! */
2582 }
2583 else
2585 }
2588 portid++;
2596 else
2600 }
2602 }
2603 }
2605 /*----------------------------------------------------------------------*/
2606 /* Add a specific port connection from object cschem into the instance */
2607 /* cinst. This equates a net number in the calling object cschem */
2608 /* (netfrom) to a net number in the object instance being called */
2609 /* (netto). */
2610 /* */
2611 /* If we attempt to connect a bus of one size to a port of a different */
2612 /* size, return FALSE. Otherwise, add the call and return TRUE. */
2613 /*----------------------------------------------------------------------*/
2616 {
2617 CalllistPtr ccall;
2619 objectptr instobj;
2620 objinstptr cinst;
2623 Boolean duplicate;
2625 /* The call that we need to add a port to is the first on */
2626 /* the list for cschem, as created by addcall(). */
2633 /* It is possible that "netfrom" is an unlabeled polygon that */
2634 /* is implicitly declared a bus by its connection to this */
2635 /* port. If so, we promote "netfrom" to a bus but set the */
2636 /* subnet entries to negative values, since we don't know what */
2637 /* they are yet. */
2639 }
2641 /* Only other allowable condition is a bus size 1 connecting into */
2642 /* a single-wire port. However, one should consider promotion of */
2643 /* the pin in the target object to a bus on a per-instance basis. */
2644 /* This has not yet been done. . . */
2647 /* Let the caller report error information, because it knows more */
2649 }
2650 }
2663 }
2676 }
2679 }
2683 }
2685 /* Check the ports of the instance's object for the one matching */
2686 /* the "netto" net ID. */
2693 /* If there is already an entry for this port, then */
2694 /* we may need to merge nets in cschem. */
2704 }
2706 /* Upon failure, see if we can merge the other */
2707 /* direction. */
2716 }
2717 }
2718 }
2719 }
2721 }
2729 }
2731 }
2732 }
2734 }
2736 }
2738 /*----------------------------------------------------------------------*/
2739 /* Find the net ID corresponding to the indicated port ID in the */
2740 /* indicated object. */
2741 /*----------------------------------------------------------------------*/
2744 {
2745 PortlistPtr plist;
2750 }
2752 }
2754 /*----------------------------------------------------------------------*/
2755 /* Traverse netlist and return netid of polygon or pin on which the */
2756 /* indicated point is located. */
2757 /* If point is not on any polygon or does not match any pin position, */
2758 /* return NULL. */
2759 /* Labels which have a non-NULL "cinst" record are instance-dependent */
2760 /* and must match parameter "cinst". */
2761 /* */
2762 /* This routine checks to see if more than one net crosses the point */
2763 /* of interest, and merges the nets if found. */
2764 /* (the method has been removed and must be reinstated, presumably) */
2765 /*----------------------------------------------------------------------*/
2768 {
2770 PolylistPtr ppoly;
2771 LabellistPtr plab;
2775 /* cschem is the object containing the point. However, if the object */
2776 /* is a secondary schematic, the netlist is located in the master. */
2787 /* if we've encountered a unique instance, then continue past */
2788 /* all other instances using this label. */
2793 }
2795 /* Check against polygons. We use this part of the routine to see */
2796 /* if there are crossing wires on top of a port. If so, they are */
2797 /* merged together. */
2809 else
2811 }
2812 }
2813 }
2816 }
2818 /*----------------------------------------------------------------------*/
2819 /* localpin keeps track of temporary pin labels when flattening the */
2820 /* hierarchy without destroying the original pin names. */
2821 /*----------------------------------------------------------------------*/
2824 {
2825 NetnamePtr netnames;
2831 /* Copy all net names which are passed from above through ports */
2840 }
2841 }
2853 }
2854 }
2855 }
2857 /*----------------------------------------------------------------------*/
2858 /* Find the first point associated with the net "netid" in the object */
2859 /* cschem. */
2860 /*----------------------------------------------------------------------*/
2863 {
2864 PolylistPtr plist;
2865 LabellistPtr llist;
2874 }
2878 }
2881 }
2883 }
2884 }
2891 }
2895 }
2898 }
2900 }
2901 }
2903 }
2905 /*----------------------------------------------------------------------*/
2906 /* Find a label element for the given net number. In a symbol, this */
2907 /* will be the label representing the pin (or the first one found, if */
2908 /* the pin has multiple labels). If no label is found, return NULL. */
2909 /* Preferably choose a non-temporary label, if one exists */
2910 /*----------------------------------------------------------------------*/
2913 {
2914 LabellistPtr llist;
2925 }
2929 }
2935 }
2937 }
2938 }
2940 }
2943 /*----------------------------------------------------------------------*/
2944 /* Find the subnet number of the given net. This routine should be */
2945 /* used only as a last resort in case the subnet number is not */
2946 /* available; it has to look through the polygon and label lists in */
2947 /* detail to find the specified net ID. */
2948 /*----------------------------------------------------------------------*/
2951 {
2952 PolylistPtr plist;
2953 LabellistPtr llist;
2963 }
2968 }
2971 }
2973 }
2974 }
2982 }
2987 }
2990 }
2992 }
2993 }
2995 }
2997 /*----------------------------------------------------------------------*/
2998 /* Find a pin name for the given net number */
2999 /* Either take the last pin name with the net, or generate a new pin, */
3000 /* assigning it a net number for a string. */
3001 /* prefix = NULL indicates spice netlist, but is also used for PCB-type */
3002 /* netlists because the calling hierarchy is generated elsewhere. */
3003 /*----------------------------------------------------------------------*/
3006 {
3007 NetnamePtr netname;
3008 labelptr pinlab;
3009 LabellistPtr netlabel;
3013 /* buslist *sbus; (jdk) */
3014 Genericlist newnet;
3017 /* prefix is NULL for hierarchical (spice) netlists and for */
3018 /* internal netlist manipulation. */
3024 /* If this is a "temp label", regenerate the name according to */
3025 /* the actual net number, if it does not match. This prevents */
3026 /* unrelated temp labels from getting the same name. */
3037 }
3038 }
3039 }
3041 }
3043 /* If there's no label associated with this network, make one */
3044 /* called "intn" where n is the net number (netid). This is a */
3045 /* temp label (denoted by lack of a font specifier). */
3052 }
3053 }
3055 /* Flattened (e.g., sim) netlists */
3062 }
3063 }
3065 /* Generate the string for the local instantiation of this pin */
3066 /* If this node does not have a pin, create one using the current */
3067 /* hierarchy prefix as the string. */
3073 }
3077 }
3081 }
3086 }
3088 /* "newstring" is allocated only once and should not be free'd */
3089 /* by the calling routine. */
3095 }
3098 }
3101 }
3103 /*----------------------------------------------------------------------*/
3104 /* Find the net which connects to the given pin label */
3105 /* Return NULL (no net) if no match was found. */
3106 /*----------------------------------------------------------------------*/
3109 {
3110 LabellistPtr seeklabel;
3115 /* check against local pins, if this pin is declared local */
3122 {
3123 /* Quick simple case: no bus */
3129 /* It is necessary to be able to put together a netlist from */
3130 /* partial sources none of which may be complete. */
3143 matched++;
3144 }
3148 }
3149 }
3150 }
3155 }
3157 }
3159 #ifdef TCL_WRAPPER
3161 /*----------------------------------------------------------------------*/
3162 /* Automatic Schematic Generation stuff--- */
3163 /* Blow away all polygons in the schematic and replace them with a */
3164 /* simple rat's-nest (point-to-point). */
3165 /* */
3166 /* This routine is more of a proof-of-concept than a useful routine, */
3167 /* intended to be called only from the Tcl console. It is intended to */
3168 /* reveal most of the issues related to automatic schematic generation, */
3169 /* in which the netlist, or a portion of it, can be redrawn as objects */
3170 /* are moved around to maintain the relationships present in the */
3171 /* calls structure. */
3172 /*----------------------------------------------------------------------*/
3175 {
3176 CalllistPtr calls;
3177 PortlistPtr ports;
3178 PolylistPtr plist;
3179 LabellistPtr llist;
3181 objinstptr cinst;
3185 XPoint portpos;
3186 Boolean result;
3191 /* Go through the netlist and remove all polygons. Remove */
3192 /* the polygons from the object as well as from the netlist. */
3197 }
3200 /* for each schematic (PRIMARY or SECONDARY), remove the tagged */
3201 /* elements. */
3208 }
3211 }
3213 /* Now, for each net ID in the label list, run through the calls and */
3214 /* find all points in the calls connecting to that net. Link */
3215 /* them with as many polygons as needed. These polygons are point- */
3216 /* to-point lines, turning the schematic representation into a */
3217 /* "rat's-nest". */
3224 }
3229 }
3234 /* Determine schematic object from the object called. Start a */
3235 /* new polygon any time we switch schematic pages. */
3244 /* Find the location of this port in the coordinates of cschem */
3248 points++;
3255 }
3256 else
3258 }
3261 /* Deal with error condition? */
3262 }
3263 }
3264 }
3265 }
3267 }
3268 }
3270 /* Now, move all the labels to reconnect to their networks */
3272 /* (to be done) */
3274 /* Refresh the screen */
3276 }
3278 #endif
3280 /*----------------------------------------------------------------------*/
3281 /* Find a net or netlist in object cschem with the indicated name. */
3282 /* */
3283 /* This is the same routine as above, but finds the net with the given */
3284 /* name, or all nets which are a subset of the given name, if the name */
3285 /* is the name of a bus. Return NULL if no match was found. */
3286 /*----------------------------------------------------------------------*/
3289 {
3290 LabellistPtr seeklabel;
3291 stringpart newstring;
3293 /* Build a simple xcircuit string from "netname" (nothing malloc'd) */
3298 /* Check against local networks */
3304 /* Check against global networks */
3311 }
3313 /*----------------------------------------------------------------------*/
3314 /* Check if two parts may have the same component index. This is true */
3315 /* for parts with parameterized pins, such as those in the "quadparts" */
3316 /* library. Compare the names of the ports in each instance. If none */
3317 /* match, then these are unique subparts of a single component, and we */
3318 /* should return FALSE. Otherwise, return TRUE. */
3319 /*----------------------------------------------------------------------*/
3322 {
3323 PortlistPtr port;
3324 labelptr plab;
3326 Boolean rvalue;
3338 }
3340 }
3342 /*----------------------------------------------------------------------*/
3343 /* Generate an index number for a device in a flat netlist format. */
3344 /* We ignore any values given to "index" (this is a to-do item, since */
3345 /* many schematics are only a single level of hierarchy, so it makes */
3346 /* sense to keep designated indices when possible), but do generate */
3347 /* independent index numbering for different device classes. */
3348 /*----------------------------------------------------------------------*/
3351 {
3356 }
3358 }
3365 }
3367 /*----------------------------------------------------------------------*/
3368 /* Free the list of per-class flat device indices */
3369 /*----------------------------------------------------------------------*/
3372 {
3378 }
3380 }
3382 /*---------------------------------------------------------*/
3383 /* Convert a number (up to 99999) to its base-36 equivalent */
3384 /*---------------------------------------------------------*/
3387 {
3400 }
3402 /*----------------------------------------------------------------------*/
3403 /* Generate an index number for this device. Count all devices having */
3404 /* the same device name (as printed in the netlist) in the calls of */
3405 /* the calling object (cfrom) */
3406 /* */
3407 /* Update (9/29/04): Remove any leading whitespace from the device */
3408 /* name to prevent treating, for example, "J?" and " J?" as separate */
3409 /* device types. */
3410 /* */
3411 /* Update (7/28/05): To allow SPICE device indices to include all */
3412 /* alphanumerics, we parse in base-36, and count in the subset of */
3413 /* base-36 that can be interpreted as decimal (1-9, 36-45, etc.) */
3414 /*----------------------------------------------------------------------*/
3417 {
3422 /* oparamptr ops; (jdk) */
3430 /* Count total number of devices */
3443 }
3444 }
3454 }
3459 }
3461 /*----------------------------------------------------------------------*/
3462 /* Generate and return a list of all info label prefixes in a design */
3463 /* This does not depend on the netlist being generated (i.e., does not */
3464 /* use CalllistPtr) */
3465 /*----------------------------------------------------------------------*/
3468 {
3471 labelptr plabel;
3472 objinstptr cinst;
3474 slistptr modeptr;
3495 }
3496 }
3497 }
3503 }
3504 }
3505 }
3507 /*----------------------------------------------------------------------*/
3508 /* Create and return an ordered list of info labels for the schematic */
3509 /* page cschem. A linked label list is returned, combining info labels */
3510 /* from all schematic pages related to cschem (master and slave pages). */
3511 /* It is the responsibility of the calling routine to free the linked */
3512 /* list. */
3513 /*----------------------------------------------------------------------*/
3516 {
3520 labelptr plabel;
3535 locpos--;
3536 }
3537 else
3548 /* Consider only positive-valued numbers. Negative */
3549 /* indices are handled by "writenet" by merging the */
3550 /* minus character into the mode name. */
3554 }
3555 else
3565 /* Order the linked list */
3570 }
3577 }
3581 }
3582 }
3583 }
3584 }
3585 }
3586 }
3588 }
3590 /*----------------------------------------------------------------------*/
3591 /* Trivial default pin name lookup. Parse an object's pin labels for */
3592 /* pin names. Return the text of the nth pin name, as counted by the */
3593 /* position in the object's parts list. If there are fewer than (n+1) */
3594 /* pin labels in the object, return NULL. Otherwise, return the pin */
3595 /* name in a malloc'd character string which the caller must free. */
3596 /*----------------------------------------------------------------------*/
3599 {
3601 labelptr plabel;
3613 }
3614 count++;
3615 }
3616 }
3617 }
3619 }
3621 /*----------------------------------------------------------------------*/
3622 /* Parse an object's info labels for pin names. This is *not* a */
3623 /* netlist function. The nth pin name is returned, or NULL if not */
3624 /* found. Return value is a malloc'd string which the caller must */
3625 /* free. */
3626 /*----------------------------------------------------------------------*/
3629 {
3631 labelptr plabel;
3647 }
3648 /* Currently we are not checking against "mode". . .*/
3649 /* interpret all characters after the colon */
3655 /* Do for all text characters */
3658 strt++;
3659 i++;
3662 strt++;
3668 }
3669 count++;
3670 }
3671 }
3672 }
3673 }
3674 }
3675 }
3676 }
3678 }
3680 /*----------------------------------------------------------------------*/
3681 /* Look for information labels in the object parts list. Parse the */
3682 /* information labels and print results to specified output device. */
3683 /* (This is not very robust to errors---needs work!) */
3684 /* */
3685 /* If "autonumber" is true, then the parsed info label is used to */
3686 /* auto-number devices. */
3687 /*----------------------------------------------------------------------*/
3691 {
3692 /* genericptr *pgen; (jdk) */
3696 PortlistPtr ports;
3700 u_int newindex;
3707 /* For flat netlists, prefix the mode with the word "flat". */
3708 /* As of 3/8/07, this includes the ".sim" format, which */
3709 /* should be called as mode "flatsim". */
3715 }
3717 /* mode == "" is passed when running resolve_devindex() and indicates */
3718 /* that the routine should be used to assign devindex to calls whose */
3719 /* devices have been manually assigned numbers. The preferred method */
3720 /* is to assign these values through the "index" parameter. Use of */
3721 /* parseinfo() ensures that objects that have no "index" parameter */
3722 /* but have valid info-labels for SPICE or PCB output will be */
3723 /* assigned the correct device index. */
3724 /* Sept. 3, 2006---The use of the prepended "@" character on */
3725 /* parameter names means that I can replace the cryptic "idx" with */
3726 /* the more obvious "index", which previously conflicted with the */
3727 /* PostScript command of the same name. Parameters "index" and "idx" */
3728 /* are treated interchangeably by the netlister. */
3733 /* 1st pass: look for valid labels; see if more than one applies. */
3734 /* If so, order them correctly. Labels may not be numbered in */
3735 /* sequence, and may begin with zero. We allow a lot of flexibility */
3736 /* but the general expectation is that sequences start at 0 or 1 and */
3737 /* increase by consecutive integers. */
3741 /* Now parse each label in sequence and output the result to */
3742 /* the return string. */
3752 /* move to colon character */
3757 }
3759 /* interpret all characters after the colon */
3764 /* Do for all text characters */
3768 strt++;
3769 i++;
3789 else
3794 }
3805 else
3824 /* drop through */
3828 /* Followed by a filename to include verbatim into */
3829 /* the output. Filename either has no spaces or */
3830 /* is in quotes. */
3832 /* Use textprint to catch any embedded parameters */
3842 }
3843 strt++;
3844 }
3847 /* No filename; print verbatim */
3851 }
3858 fnsh++;
3864 /* Do variable and tilde expansion on the filename */
3868 /* Check if this file has been included already */
3873 }
3875 }
3877 /* Open the indicated file and dump to the output */
3889 }
3891 }
3894 }
3899 /* Pin name either has no spaces or is in quotes */
3900 strt++;
3903 strt++;
3904 i++;
3905 }
3909 fnsh++;
3913 /* if (is_quoted || *fnsh == '\0') i++; */
3916 /* Find the port which corresponds to this pin name */
3917 /* in the called object (cschem). If this is a */
3918 /* linked symbol/schematic, then the port list will */
3919 /* be in the schematic view, not in the symbol view */
3931 // NOTE: _STR is used inside textprintsubnet()
3937 }
3938 else
3940 }
3943 /* Find the matching port in the calling object instance */
3959 }
3962 }
3963 }
3966 }
3969 /* Parameter name either has no spaces or is in quotes */
3970 strt++;
3973 strt++;
3974 i++;
3975 }
3979 fnsh++;
3983 /* if (is_quoted || *fnsh == '\0') i++; */
3986 /* Compare this name against the parameter keys */
3989 /* For backwards compatibility, also try matching against */
3990 /* the parameter default value (method used before */
3991 /* implementing parameters as key:value pairs). */
3997 /* substitute the parameter or default */
4006 }
4008 }
4009 }
4010 }
4011 }
4016 }
4020 /* Presence of ".ends" statement forces xcircuit */
4021 /* not to write ".end" at the end of the netlist. */
4030 }
4031 }
4037 /* Parameters with unresolved question marks are treated */
4038 /* like a "%i" string. */
4044 else
4050 }
4052 /* When called with autonumber = TRUE, generate a parameter */
4053 /* instance, replacing the question mark with the new index */
4054 /* number. */
4064 }
4067 }
4068 }
4070 /* A "?" default parameter that has a (different) */
4071 /* instance value becomes the device number. */
4076 CalllistPtr plist;
4079 /* Ignore the value and generate one instead */
4087 }
4090 /* Interpret parameter string as a component */
4091 /* number so we can check for duplicates. Assume */
4092 /* a base-36 number, which includes all alphabet */
4093 /* characters. This will disambiguate, e.g., "1" */
4094 /* and "1R", but flag case-sensitivity, e.g., */
4095 /* "1R" and "1r". Thanks to Carsten Thomas for */
4096 /* pointing out the problem with assuming */
4097 /* numerical component values. */
4104 }
4110 /* Two parts have been named the same. Flag */
4111 /* it, but don't try to do anything about it. */
4112 /* 11/22/06---additionally check part numbers, */
4113 /* in case the symbol is a component sub-part. */
4120 }
4121 }
4122 }
4123 }
4124 }
4125 }
4126 }
4130 /* By convention, greek "mu" becomes ASCII "u", NOT "m", */
4131 /* otherwise we get, e.g., millifarads instead of microfarads */
4135 else
4138 }
4139 }
4140 }
4142 /* Some label controls are interpreted. Most are ignored */
4163 }
4164 }
4165 }
4167 /* Insert a newline between multiple valid info labels */
4171 }
4172 }
4178 }
4180 }
4182 /*----------------------------------------------------------------------*/
4183 /* Write a low-level device */
4184 /*----------------------------------------------------------------------*/
4188 {
4190 objectptr cthis;
4195 }
4197 /* Devices are always symbols. If the call indicates a schematic */
4198 /* and a separate associated symbol, then we want the symbol. */
4199 /* If we're writing a flat netlist, then return -1 to indicate that */
4200 /* the symbol instance needs to be flattened. */
4204 SECONDARY)
4208 else
4210 }
4212 /* Look for information labels in the object parts list. */
4218 }
4221 }
4223 /* Information labels do not necessarily exist. */
4225 }
4227 #ifdef TCL_WRAPPER
4229 /*----------------------------------------------------------------------*/
4230 /* Translate a hierarchical net name into an object and instance. */
4231 /* Return TRUE if found, FALSE if not. If found, object and instance */
4232 /* are returned in the argument pointers. */
4233 /*----------------------------------------------------------------------*/
4236 {
4237 CalllistPtr calls;
4240 objinstptr newinst;
4242 /* pushlistptr stackentry; (jdk) */
4251 }
4252 }
4263 }
4264 else
4266 }
4269 /* check to make sure that the netlist and device indices have been generated */
4274 }
4275 }
4277 /* hptr is now the object name, and devindex is the instance's call index */
4278 /* find the object corresponding to the name. */
4284 /* Try device names (for netlist output) instead of object names */
4293 }
4297 }
4298 }
4299 }
4300 }
4301 }
4306 }
4311 }
4313 /* Diagnostic information */
4314 /* fprintf(stderr, "object %s(%d) = %s\n", newobj->name, devindex, hptr); */
4323 }
4325 }
4327 #endif
4329 /*----------------------------------------------------------------------*/
4330 /* Save netlist into a flattened sim or spice file */
4331 /*----------------------------------------------------------------------*/
4334 {
4338 /* reset device indexes */
4343 /* The naming convention for nodes below the top level uses a */
4344 /* slash-separated list of hierarchical names. Thus the call to */
4345 /* the hierarchical resolve_indices(). Indices used by bottom-most */
4346 /* symbols (e.g., flattened spice) will be generated by a separate */
4347 /* routine devflatindex(), unrelated to what is generated here, */
4348 /* which only affects the hierarchical naming of nodes. */
4352 /* write all the subcircuits */
4363 /* Allow cross-referenced parameters between symbols and schematics */
4364 /* by substituting into a schematic from its corresponding symbol */
4366 /* psubstitute(calls->callinst); */
4368 }
4370 }
4372 }
4374 /*----------------------------------------------------------------------*/
4375 /* Topmost call to write a flattened netlist */
4376 /*----------------------------------------------------------------------*/
4380 {
4383 Calllist loccalls;
4385 /* Set up local call list for parsing info labels in the top-level schematic */
4398 /* "<mode>@" lines go in front */
4402 FALSE);
4408 }
4413 /* Check for negative-numbered info labels, indicated output that */
4414 /* should be processed after everything else. */
4423 }
4425 }
4427 /*----------------------------------------------------------------------*/
4428 /* Write out the list of global nets and their pin names */
4429 /*----------------------------------------------------------------------*/
4432 {
4433 LabellistPtr llist;
4434 labelptr gpin;
4445 }
4447 }
4449 /*----------------------------------------------------------------------*/
4450 /* Write a SPICE subcircuit entry. */
4451 /*----------------------------------------------------------------------*/
4454 {
4455 PortlistPtr ports;
4460 /* Objects which have no ports are not written */
4466 /* List of parameters in subcircuit. */
4467 /* Each parameter connects to a net which may have multiple */
4468 /* names, so find the net associated with the parameter */
4469 /* and convert it back into a pin name in the usual manner */
4470 /* using nettopin(). */
4482 }
4486 }
4488 }
4489 }
4491 /*----------------------------------------------------------------------*/
4492 /* Resolve device names (fill calllist structure member "devname") */
4493 /*----------------------------------------------------------------------*/
4496 {
4497 CalllistPtr calls;
4499 oparamptr ops;
4505 }
4509 /* Check for "class" parameter. Note that although this */
4510 /* parameter may take a different instance value, the */
4511 /* device class is determined by the default value. */
4517 /* The slow way---parse info labels for any device information */
4521 }
4522 }
4523 }
4524 }
4526 /*----------------------------------------------------------------------*/
4527 /* Resolve (hierarchical) component numbering. If "autonumber" is TRUE */
4528 /* then this routine does auto-numbering. Otherwise, it auto-generates */
4529 /* device indices internally (in the "calllist" structure) but does not */
4530 /* copy them into parameter space. */
4531 /* */
4532 /* Note: resolve_devindex() only operates on a single object. Use */
4533 /* resolve_indices() to operate on the entire hierarchy. */
4534 /*----------------------------------------------------------------------*/
4537 {
4538 CalllistPtr calls;
4542 objinstptr cinst;
4548 /* Check if there is an "index" parameter set to "?" in */
4549 /* the object with no existing instance value. */
4567 }
4572 /* Not a simple string. Dump the text. */
4577 }
4580 }
4582 /* It is possible to get an instance value that is */
4583 /* the same as the default, although this normally */
4584 /* doesn't happen. If it does, quietly remove the */
4585 /* unneeded instance value. */
4589 else
4595 }
4596 else
4598 }
4601 }
4602 }
4603 }
4605 /* The slow way---parse info labels for any index information */
4609 }
4610 }
4611 }
4613 /*----------------------------------------------------------------------*/
4614 /* Recursive call to resolve_devindex() through the circuit hierarchy */
4615 /*----------------------------------------------------------------------*/
4618 CalllistPtr calls;
4624 }
4625 }
4627 }
4629 /*----------------------------------------------------------------------*/
4630 /* Recursive call to clear all generated device numbers. */
4631 /*----------------------------------------------------------------------*/
4634 CalllistPtr calls;
4640 }
4642 }
4643 }
4645 /*----------------------------------------------------------------------*/
4646 /* Recursive call to clear all device indexes (parameter "index") */
4647 /*----------------------------------------------------------------------*/
4650 CalllistPtr calls;
4659 }
4669 }
4670 }
4671 }
4672 }
4674 /*----------------------------------------------------------------------*/
4675 /* Save netlist into a hierarchical file */
4676 /*----------------------------------------------------------------------*/
4680 {
4686 Calllist loccalls;
4690 /* Set up local call list for parsing info labels in this schematic */
4703 /* "<mode>@" lines go before any subcircuit calls */
4707 FALSE);
4713 }
4715 /* Subcircuits which make no calls or have no devices do not get written */
4719 /* Make sure that all the subcircuits have been written first */
4726 }
4727 }
4731 }
4732 }
4734 /* Info-labels on a schematic (if any) get printed out first */
4740 /* Check stsave for embedded SPICE subcircuit syntax */
4750 }
4752 /* top-level schematics will be ignored because they have no ports */
4754 }
4756 /* Resolve all fixed part assignments (devindex) */
4759 /* If the output file is NULL, then we're done */
4764 }
4768 /* writedevice() is just another call to parseinfo() */
4771 /* If the device did not produce any output in writedevice(), but */
4772 /* does not make any calls itself, then it is implicitly a TRIVIAL */
4773 /* symbol. */
4778 /* No syntax indicating how to write this call. Use SPICE "X" */
4779 /* format and arrange the parameters according to the structure. */
4786 /* The object's definition lists calls in the order of the object's */
4787 /* port list. Therefore, use this order to find the port list. */
4788 /* This will also deal with the fact that not every port has to be */
4789 /* called by the instance (ports may be left disconnected). */
4806 }
4810 }
4814 }
4815 }
4817 /* Check for negative-numbered info labels, indicated output that */
4818 /* should be processed after everything else. If we're processing */
4819 /* SPICE output but the schematic does not provide a ".ends" */
4820 /* statement, then add it to the end of the deck. */
4833 }
4838 }
4841 }
4843 /*----------------------------------------------------------------------*/
4844 /* Create generic netlist in the Tcl interpreter variable space */
4845 /*----------------------------------------------------------------------*/
4847 #ifdef TCL_WRAPPER
4850 {
4852 labelptr plabel;
4862 }
4863 }
4864 }
4866 }
4868 /*----------------------------------------------------------------------*/
4869 /* Write global variables to Tcl list (in key-value pairs which can be */
4870 /* turned into an array variable using the "array set" command) */
4871 /* */
4872 /* Note: argument "cinst" is unused, but it really should be. We */
4873 /* should not assume that different schematics have the same list of */
4874 /* globals! */
4875 /*----------------------------------------------------------------------*/
4878 {
4879 LabellistPtr llist;
4880 labelptr gpin;
4892 }
4896 }
4899 }
4900 }
4902 }
4904 /*----------------------------------------------------------------------*/
4905 /* Write a generic hierarchical netlist into Tcl list "subcircuits" */
4906 /*----------------------------------------------------------------------*/
4909 {
4918 /* Trivial objects are by definition those that are supposed */
4919 /* to be resolved by the netlist generation prior to output */
4920 /* and ignored by the output generator. */
4924 /* Make sure that all the subcircuits have been written first */
4930 }
4931 }
4933 /* Write own subcircuit netlist */
4936 /* Prepare the list of network cross-references */
4939 /* Make list of the nets which have been written so we don't redundantly */
4940 /* list any entries (use of calloc() initializes all entries to FALSE). */
4941 /* (calloc() replaced by malloc() and bzero() because Tcl doesn't */
4942 /* have a calloc() function (2/6/04)) */
4945 #ifdef _MSC_VER
4947 #else
4949 #endif
4951 /* Write the name (key value pair) */
4956 /* Write the handle of the object instance (key value pair) */
4960 /* Write the list of ports */
4963 /* List of ports in subcircuit. */
4964 /* Each parameter connects to a net which may have multiple */
4965 /* names, so find the net associated with the parameter */
4966 /* and convert it back into a pin name in the usual manner */
4967 /* using nettopin(). */
4978 {
4982 /* record this net as having been added to the list */
4984 }
4985 }
4988 }
4990 /* Write the list of parameter defaults (key:value pairs) */
5009 /* Should get rid of last entry, "End Parameter"; not needed */
5016 }
5017 }
5020 }
5022 /* Write the list of calls to subcircuits */
5028 /* Don't write calls to non-functional subcircuits. */
5038 /* Log any local parameter instances */
5063 }
5064 }
5068 }
5070 /* Called ports are listed by key:value pair (port number: net id) */
5088 {
5092 /* record this net as having been added to the list */
5094 }
5095 }
5099 }
5101 }
5104 }
5107 /* If the object has info labels, write a device list. */
5108 /* Check both the schematic and its symbol for info labels. */
5114 }
5120 /* Write the network cross-reference dictionary */
5125 }
5127 /*----------------------------------------------------------------------*/
5130 {
5138 }
5142 /*----------------------------------------------------------------------*/
5143 /* Create generic netlist in the Python interpreter variable space */
5144 /*----------------------------------------------------------------------*/
5146 #ifdef HAVE_PYTHON
5149 {
5151 labelptr plabel;
5160 }
5161 }
5163 }
5165 /*----------------------------------------------------------------------*/
5166 /* Write global variables to Python dictionary */
5167 /*----------------------------------------------------------------------*/
5170 {
5171 LabellistPtr llist;
5172 labelptr gpin;
5186 }
5190 }
5191 }
5193 }
5195 /*----------------------------------------------------------------------*/
5196 /* Write a generic hierarchical netlist into Python list "subcircuits" */
5197 /*----------------------------------------------------------------------*/
5200 {
5206 oparamptr paramlist;
5208 /* Trivial objects are by definition those that are supposed */
5209 /* to be resolved by the netlist generation prior to output */
5210 /* and ignored by the output generator. */
5214 /* Make sure that all the subcircuits have been written first */
5220 }
5221 }
5223 /* Write own subcircuit netlist */
5226 /* Prepare the dictionary of network cross-references */
5229 /* Write the name */
5233 /* Write the list of ports */
5236 /* List of ports in subcircuit. */
5237 /* Each parameter connects to a net which may have multiple */
5238 /* names, so find the net associated with the parameter */
5239 /* and convert it back into a pin name in the usual manner */
5240 /* using nettopin(). */
5250 }
5252 }
5254 /* Write the list of parameters */
5268 /* Should get rid of last entry, "End Parameter"; not needed */
5270 }
5271 }
5273 }
5275 /* Write the list of calls to subcircuits */
5281 /* Don't write calls to non-functional subcircuits. */
5288 /* Log any local parameter instances */
5303 }
5305 pyparams);
5306 }
5308 /* The object's definition lists calls in the order of the object's */
5309 /* port list. Therefore, use this order to find the port list. */
5310 /* Unconnected ports will be NULL entries in the list (?). */
5328 }
5330 }
5332 }
5334 }
5336 /* If the object has info labels, write a device list. */
5337 /* Check both the schematic and its symbol for info labels. */
5343 }
5348 /* Write the network cross-reference dictionary */
5352 }
5354 /*----------------------------------------------------------------------*/
5357 {
5364 }
5368 /*----------------------------------------------------------------------*/
5369 /* Update networks in an object by checking if the network is valid, */
5370 /* and destroying and recreating the network if necessary. */
5371 /* */
5372 /* Run cleartraversed() on all types. The traversed flag allows a */
5373 /* check for infinite recursion when creating calls. */
5374 /* */
5375 /* Returns -1 on discovery of infinite recursion, 0 on failure to */
5376 /* generate a net, and 1 on success. */
5377 /*----------------------------------------------------------------------*/
5380 objectptr thisobject;
5381 objinstptr thisinst;
5384 /* Never try to generate a netlist while a file is being read, as */
5385 /* can happen if an expression parameter attempts to query a netlist */
5386 /* node. */
5395 }
5399 }
5407 }
5409 /* Note: destroy/create nets messes up the part list. Why?? */
5419 }
5420 }
5427 }
5429 }
5431 /*----------------------------------------------------------------------*/
5432 /* Generate netlist, write information according to mode, and then */
5433 /* destroy the netlist (this will be replaced eventually with a dynamic */
5434 /* netlist model in which the netlist changes according to editing of */
5435 /* individual elements, not created and destroyed wholesale) */
5436 /*----------------------------------------------------------------------*/
5439 {
5440 objectptr cschem;
5441 objinstptr thisinst;
5445 /* Calllist topcell; (jdk) */
5448 /* Always use the master schematic, if there is one. */
5452 else
5455 /* Update the netlist if this has not been done */
5460 }
5464 }
5476 }
5481 }
5483 /* Clear device indices from any previous netlist output */
5487 /* Make sure list of include-once files is empty */
5491 /* Handle different netlist modes */
5503 /* writeglobals(cschem, fp); */
5506 }
5514 }
5516 }
5524 }
5527 }
5534 }
5536 }
5543 }
5546 }
5548 /* User-defined modes beginning with the word "flat": */
5549 /* Assume a flattened netlist, and assume nothing else. */
5556 }
5558 /* User-defined modes beginning with the word "pseu": */
5559 /* Assume a flattened netlist for everything under the top level. */
5565 }
5567 /* All user-defined modes: Assume a hierarchical netlist, and */
5568 /* assume nothing else. */
5574 }
5576 /* Finish up SPICE files with a ".end" statement (if requested) */
5580 /* Finish up */
5585 }
5588 }
5590 /*----------------------------------------------------------------------*/
5591 /* Flatten netlist and save into a table of pcb-style nets */
5592 /* The routine is recursive. Each call returns TRUE if some nested */
5593 /* call generated output; this is a reasonable way to tell if we have */
5594 /* reached the bottom of the hierarchy. */
5595 /*----------------------------------------------------------------------*/
5599 {
5600 PolylistPtr plist;
5601 LabellistPtr llist;
5602 CalllistPtr calls;
5603 PortlistPtr ports;
5610 objinstptr cinst;
5614 Boolean outputcall;
5616 /* Step 1A: Go through the polygons of this object and add */
5617 /* any unvisited nets to the table. */
5626 }
5634 }
5636 }
5649 /* Fprintf(stdout, "Added new index entry for net %d\n", testnet); */
5650 }
5652 }
5653 }
5655 /* Step 1B: Do the same thing for labels. */
5664 }
5672 }
5674 }
5687 /* Fprintf(stdout, "Added new index entry for net %d\n", testnet); */
5688 }
5690 }
5691 }
5693 /* Step 2: Resolve fixed device indices */
5696 /* Step 3: Go through the list of calls to search for endpoints */
5699 objectptr cthis;
5703 /* Trivial objects should have been dealt with already. */
5704 /* If we don't continue the loop here, you get netlist output for */
5705 /* objects like dots and circles. */
5708 /* Step 4: If call is to a bottom-most schematic, output the device connections */
5709 /* Info-label can provide an alternate name or specify the instance number */
5713 SECONDARY)
5721 }
5724 }
5729 /*----------------------------------------------------------------*/
5730 /* Parsing of the "pcb:" info label--- */
5731 /* Find all <net>=<name> strings and create the appropriate nets */
5732 /*----------------------------------------------------------------*/
5745 rhs++;
5752 /* Get the net from the equation RHS. If none exists, assume */
5753 /* the name is a global net and add it to the list of globals. */
5758 label templabel;
5769 }
5771 /* Get the name of the pin */
5777 /* Find the net in the ptable, or create a new entry for it */
5786 }
5788 }
5802 }
5804 /* Check if any entries are the same as tmppinname */
5808 }
5809 }
5811 /* Get the pin name from the equation LHS */
5820 }
5823 }
5825 /* Proceed to the next LHS=RHS pair */
5828 }
5830 }
5835 /* Step 4A: Push current net translations */
5836 /* (Don't push or pop global net numbers: no translation needed!) */
5847 }
5849 }
5851 /* Step 4B: Generate net translation table for each subcircuit */
5861 }
5866 }
5867 }
5868 }
5873 else
5877 /* Translate net value */
5882 /* Fprintf(stdout, "Translation: net %d in object %s is net "
5883 "%d in object %s\n", ports->netid, cschem->name,
5884 locnet, calls->callobj->name); */
5885 }
5886 }
5888 /* Step 4C: Run routine recursively on the subcircuit */
5889 /* If it had a "pcb:" info label that was handled, then ignore */
5891 /* Fprintf(stdout, "Recursive call of writepcb() to %s\n",
5892 calls->callobj->name); */
5896 /* Step 4D: Pop the translation table */
5897 /* (Don't pop global nets (designated by negative net number)) */
5907 }
5909 }
5910 }
5915 /* Fprintf(stdout, "Reached lowest-level schematic: Finding connections\n"); */
5918 /* Global pin names should probably be ignored, not just */
5919 /* when an object is declared to be "trivial". Not sure if */
5920 /* this breaks certain netlists. . . */
5923 /* Get the name of the pin in the called object with no prefix. */
5929 /* Global nets were not translated, do not iterate through list */
5937 }
5938 }
5940 }
5945 }
5957 /* Replace slash '/' with dash '-' at bottommost level */
5965 /* diagnostic information */
5966 {
5971 ctr++;
5972 }
5973 /* Fprintf(stdout, "Logged level-%d net %d (local net %d) pin %s\n",
5974 ctr, *(locnet->netidx), *(hidx->nets->netidx + i),
5975 tmpstr->string); */
5976 }
5977 }
5978 }
5979 }
5980 }
5982 /* Step 5: Cleanup */
5986 }
5988 /*----------------------------------------------------------------------*/
5989 /* Save PCB table into pcb-style file */
5990 /*----------------------------------------------------------------------*/
5993 {
6010 }
6011 else
6020 }
6024 }
6026 }
6027 /* else fprintf(fp, "NET%d *UNCONNECTED*\n", netidx++); */
6028 }
6029 }
6031 /*----------------------------------------------*/
6032 /* free memory allocated to PCB net tables */
6033 /*----------------------------------------------*/
6036 {
6054 }
6063 }
6067 }
6068 }
6070 /*----------------------------------------------------------------------*/
6071 /* Remove an element from the netlist. This is necessary when an */
6072 /* element is deleted from the object, so that the netlist does not */
6073 /* refer to a nonexistant element, or try to perform netlist function */
6074 /* on it. */
6075 /* */
6076 /* Return True or False depending on whether a pin was "orphaned" on */
6077 /* the corresponding schematic or symbol (if any), as this may cause */
6078 /* the class of the object (FUNDAMENTAL, TRIVIAL, etc.) to change. */
6079 /*----------------------------------------------------------------------*/
6082 {
6084 labelptr nlab;
6085 polyptr npoly;
6086 objectptr pschem;
6087 objinstptr ninst;
6099 /* If this is an object instance, remove it from the calls */
6105 else
6110 }
6111 else
6113 }
6120 /* If this is a polygon, remove it from the netlist */
6126 else
6131 }
6132 else
6134 }
6141 /* If this is a label, remove it from the netlist */
6147 else
6152 }
6153 else
6155 }
6157 /* Mark pin label in corresponding schematic/symbol as "orphaned" */
6158 /* by changing designation from type "pin" to type "label". */
6163 }
6164 }
6166 }
6168 /*----------------------------------------------------------------------*/
6169 /* Remove one element from the netlist */
6170 /*----------------------------------------------------------------------*/
6174 objectptr pschem;
6180 /* Always call on the primary schematic */
6185 /* remove polygon from polygon list */
6196 else
6199 }
6200 else
6203 }
6208 /* remove label from label list */
6219 else
6222 }
6223 else
6226 }
6228 /* also check the globals */
6239 else
6242 }
6243 else
6246 }
6251 /* remove instance from call list */
6260 else
6262 }
6263 else
6266 }
6268 }
6271 }
6273 /*----------------------------------------------------------------------*/
6274 /* Free memory allocated for the ports in a calls. */
6275 /*----------------------------------------------------------------------*/
6278 {
6285 }
6288 }
6290 /*----------------------------------------------------------------------*/
6291 /* Free memory for a Genericlist structure (may also be a Labellist or */
6292 /* Polylist structure). */
6293 /*----------------------------------------------------------------------*/
6296 {
6301 }
6303 /*----------------------------------------------------------------------*/
6304 /* Free memory allocated for the label list in a netlist. */
6305 /*----------------------------------------------------------------------*/
6308 {
6315 }
6317 }
6319 /*----------------------------------------------------------------------*/
6320 /* Free memory allocated for the polygon list in a netlist. */
6321 /*----------------------------------------------------------------------*/
6324 {
6331 }
6333 }
6335 /*----------------------------------------------------------------------*/
6336 /* Free memory allocated for netlist */
6337 /*----------------------------------------------------------------------*/
6340 {
6348 }
6350 /*----------------------------------------------------------------------*/
6351 /* Clear the "traversed" flag in all objects of the hierarchy. */
6352 /*----------------------------------------------------------------------*/
6355 {
6357 objinstptr cinst;
6360 /* Always call on the primary schematic */
6363 /* Recursively call cleartraversed() on all subobjects, a la gennetlist() */
6364 /* Use the parts list of the object, not the calls, because calls */
6365 /* may have been removed. */
6375 else
6378 /* Don't infinitely recurse if object is on its own schematic */
6379 /* However, we need to take a stab at more subtle recursion, too */
6384 }
6385 }
6389 }
6391 /*----------------------------------------------------------------------*/
6392 /* This is the routine normally called, as it hides the "level" */
6393 /* argument tagging the level of recursion. */
6394 /*----------------------------------------------------------------------*/
6398 }
6400 /*----------------------------------------------------------------------*/
6401 /* If any part of the netlist is invalid, destroy the entire netlist */
6402 /*----------------------------------------------------------------------*/
6405 {
6407 objinstptr cinst;
6410 /* If the object has been declared a non-network object, ignore it */
6413 /* Always operate on the master schematic */
6416 /* Stop immediately if the netlist is invalid */
6419 /* Otherwise, recursively call checkvalid() on all subobjects. */
6420 /* Use the parts list of the object, not the calls, because calls */
6421 /* may have been removed. */
6429 else
6432 /* Don't infinitely recurse if object is on its own schematic */
6436 /* If there is a symbol, don't check its parts, but check if */
6437 /* its netlist has been checkvalid. */
6445 /* Recursive call on subschematic */
6448 }
6449 }
6451 }
6453 /*----------------------------------------------------------------------*/
6454 /* Free memory allocated to temporary labels generated for the netlist */
6455 /*----------------------------------------------------------------------*/
6458 {
6460 objinstptr cinst;
6461 objectptr callobj;
6463 /* Recursively call freetemplabels() on all subobjects, a la gennetlist() */
6464 /* Use the parts list of the object, not the calls, because calls */
6465 /* may have been removed. */
6473 else
6476 /* Don't infinitely recurse if object is on its own schematic */
6479 /* Also free the temp labels of any associated symbol */
6481 }
6483 /* Free any temporary labels which have been created */
6487 /* int tmpval = (int)(cgen - cschem->plist); (jdk) */
6497 cgen--;
6498 }
6499 }
6500 }
6501 }
6503 /*----------------------------------------------------------------------*/
6504 /* Free memory allocated for netlists, ports, and calls */
6505 /*----------------------------------------------------------------------*/
6508 {
6512 objinstptr cinst;
6513 objectptr callobj;
6515 /* Recursively call freenets() on all subobjects, a la gennetlist() */
6516 /* Use the parts list of the object, not the calls, because calls */
6517 /* may have been removed. */
6527 else
6530 /* Don't infinitely recurse if object is on its own schematic */
6533 /* Also free the netlist of any associated symbol */
6535 }
6536 }
6537 }
6539 /* Free the allocated structures for this object */
6545 }
6552 }
6562 }
6564 /*----------------------------------------------------------------------*/
6565 /* Free the global pin list */
6566 /*----------------------------------------------------------------------*/
6569 {
6575 /* Labels in the global list are temporary and must be deallocated */
6581 }
6583 }
6585 /*----------------------------------------------------------------------*/
6586 /* Get rid of locally-defined pin names */
6587 /*----------------------------------------------------------------------*/
6590 {
6597 }
6600 }
6602 }
6604 /*----------------------------------------------------------------------*/
6605 /* Handle lists of included files */
6606 /*----------------------------------------------------------------------*/
6608 /*----------------------------------------------------------------------*/
6609 /* check_included() --- check if a file has already been included. */
6610 /* Check by inode instead of filename so that we cannot trick the */
6611 /* program by giving, e.g., one relative path and one full path. */
6612 /*----------------------------------------------------------------------*/
6615 {
6623 }
6624 }
6626 }
6628 /*----------------------------------------------------------------------*/
6629 /* append_included() --- update the list of included files by adding */
6630 /* the inode of filename to the list. */
6631 /*----------------------------------------------------------------------*/
6634 {
6644 }
6653 }
6654 }
6657 }
6658 }
6660 /*----------------------------------------------------------------------*/
6663 {
6667 }
6668 }
6670 /*-------------------------------------------------------------------------*/