| blob | 3af9481d7296bf5e1dbb68c63f375c01e5af73ec |
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 /* Ignore any instance that is specifically marked non-netlistable */
1141 /* Determine where the hierarchy continues downward */
1145 else
1148 /* Always ignore any object on its own schematic */
1154 /* Note: callobj is the next schematic in the hierarchy. */
1155 /* callsymb is the next visible object in the hierarchy, */
1156 /* which may be either a schematic or a symbol. */
1158 /*--------------------------------------------------------------*/
1159 /* For object instances which are their own schematics (i.e., */
1160 /* have netlist elements), don't rely on any pin list but make */
1161 /* a survey of how polygons connect into the object. */
1162 /*--------------------------------------------------------------*/
1168 /* Fprintf(stdout, "*** Analyzing connections from %s"
1169 " to instance of %s\n", cschem->name,
1170 callinst->thisobject->name); */
1172 /* Look for pins connecting to pins in the object */
1180 /* if we've encountered a unique instance, then con- */
1181 /* tinue past all other instances using this label. */
1185 }
1187 /* Look for polygon ends connecting into the object */
1193 }
1195 /* For each call to a schematic or symbol which is NOT the */
1196 /* one under consideration, see if it touches or overlaps */
1197 /* the object under consideration. Search for connections */
1198 /* between the two objects. */
1202 /* Only need to look forward from the current position. */
1209 /* Check intersection of the two object instances; */
1210 /* don't do a search if they are disjoint. */
1217 }
1218 }
1219 }
1220 }
1222 /*----------------------------------------------------------*/
1223 /* Recursively call gencalls() on the schematic. */
1224 /*----------------------------------------------------------*/
1229 /*----------------------------------------------------------*/
1230 /* Create a call to the object callsymb from object cschem */
1231 /*----------------------------------------------------------*/
1235 /*----------------------------------------------------------*/
1236 /* Search again on symbol pins to generate calls to ports. */
1237 /*----------------------------------------------------------*/
1244 /* LabellistPtr slab; (jdk) */
1245 /* labelptr slabel; (jdk) */
1254 /* Translate pin position back to object cschem */
1257 /* What net in the calling object connects to this point? */
1260 /* If there's no net, we make one */
1264 /* Generate a port call for a global signal if the */
1265 /* global label appears in the symbol (9/29/04). This */
1266 /* is a change from previous behavior, which was to not */
1267 /* make the call. */
1272 /* Attempt to generate a port in the object. */
1275 /* Generate the call to the port */
1278 // If object is "dot" then copy the bus from the
1279 // net to the dot. The dot takes on whatever
1280 // dimension the bus is.
1284 }
1290 }
1291 }
1293 /* if we've encountered a unique instance, then continue */
1294 /* past all other instances using this label. */
1298 }
1300 /*----------------------------------------------------------*/
1301 /* If after all that, no ports were called, then remove the */
1302 /* call to this object instance. However, we should check */
1303 /* for info labels, because the device may produce output */
1304 /* for the netlist even if it has no declared ports. This */
1305 /* is irrespective of the presence of pin labels---if the */
1306 /* symbol is "trivial", the netlist connections are */
1307 /* resolved in the level of the hierarchy above, and there */
1308 /* may be no ports, but the call list must retain the call */
1309 /* to ensure that the netlist output is generated. */
1310 /*----------------------------------------------------------*/
1315 }
1316 }
1317 }
1318 }
1320 /*----------------------------------------------------------------------*/
1321 /* Translate a net number down in the calling hierarchy */
1322 /*----------------------------------------------------------------------*/
1325 {
1326 PortlistPtr nport;
1333 }
1334 }
1336 }
1338 /*----------------------------------------------------------------------*/
1339 /* Translate a netlist up in the calling hierarchy */
1340 /* */
1341 /* This routine creates a new netlist header which needs to be freed */
1342 /* by the calling routine. */
1343 /* */
1344 /* Note that if the entire netlist cannot be translated up, then the */
1345 /* routine returns NULL. This could be modified to return the part of */
1346 /* the network that can be translated up. */
1347 /*----------------------------------------------------------------------*/
1351 {
1352 PortlistPtr nport;
1353 CalllistPtr ccall;
1371 }
1376 }
1377 }
1386 }
1387 }
1389 }
1390 }
1394 }
1398 }
1403 }
1404 }
1406 }
1408 }
1410 /*----------------------------------------------------------------------*/
1411 /* Check whether the indicated polygon is already resolved into the */
1412 /* netlist of the object hierarchy described by seltop. */
1413 /* Return the netlist if resolved, NULL otherwise. The netlist */
1414 /* returned is referred (translated) upward through the calling */
1415 /* hierarchy to the topmost object containing that net or those nets. */
1416 /* This topmost object is returned in parameter topobj. */
1417 /* Note that the netlist returned does not necessarily correspond to */
1418 /* any object in the top level. It is allocated and must be freed by */
1419 /* the calling routine. */
1420 /*----------------------------------------------------------------------*/
1423 {
1425 objectptr pschem;
1426 PolylistPtr pseek;
1427 LabellistPtr lseek;
1432 /* Recursively call self, since we have to back out from the bottom of */
1433 /* the stack. */
1438 /* Translate network ID up the hierarchy to the topmost object in which */
1439 /* the network exists. */
1445 /* Net does not exist upwards of this object. Pass net ID */
1446 /* upward with "topobj" unchanged. */
1451 }
1452 }
1453 }
1456 /* Find the net ID for the listed object, which should be in the object */
1457 /* on the bottom of the pushlist stack. */
1464 }
1465 }
1466 }
1472 }
1473 }
1474 }
1477 /* Make a copy of the netlist header from this element */
1482 }
1483 }
1485 /* done: (jdk) */
1488 }
1490 /*--------------------------------------------------------------*/
1491 /* Highlight all the polygons and pin labels in a network */
1492 /* (recursively, downward). Pin labels are drawn only on the */
1493 /* topmost schematic object. */
1494 /* Returns true if some part of the hierarchy declared a net to */
1495 /* be highlighted. */
1496 /* mode = 1 highlight, mode = 0 erase */
1497 /*--------------------------------------------------------------*/
1500 {
1501 CalllistPtr calls;
1502 PortlistPtr ports;
1503 PolylistPtr plist;
1504 LabellistPtr llist;
1505 polyptr cpoly;
1506 labelptr clabel;
1507 objinstptr ccinst;
1511 objectptr pschem;
1523 else
1526 /* Fprintf(stdout, " >> Found polygon belonging to net %d at (%d, %d)\n",
1527 locnetid, cpoly->points[0].x, cpoly->points[0].y); */
1531 }
1534 }
1536 }
1537 }
1539 /* Highlight labels if they belong to the top-level object */
1549 else
1556 }
1557 else
1559 /* Fprintf(stdout, " >> Found label belonging to net "
1560 "%d at (%d, %d)\n",
1561 locnetid, clabel->position.x,
1562 clabel->position.y); */
1564 }
1566 }
1568 }
1569 /* if we've encountered a unique instance, then continue */
1570 /* past all other instances using this label. */
1574 }
1576 /* Highlight all pins connecting this net to symbols */
1578 }
1580 /* Connectivity recursion */
1588 /* Recurse only on objects for which network polygons are visible */
1589 /* from the calling object: i.e., non-trivial, non-fundamental */
1590 /* objects acting as their own schematics. */
1601 /* Fprintf(stdout, " > Calling object %s at (%d, %d)\n",
1602 calls->callobj->name, ccinst->position.x, ccinst->position.y); */
1603 /* Fprintf(stdout, " > Net translation from %d to %d (port %d)\n",
1604 netid, netto, ports->portid); */
1608 }
1610 /* Otherwise (symbols, fundamental, trivial, etc., objects), we */
1611 /* highlight the pin position of the port. */
1614 }
1616 }
1617 }
1618 }
1620 }
1622 /*----------------------------------------------------------------------*/
1623 /* Highlight whatever nets are listed in the current object instance, */
1624 /* if any. */
1625 /*----------------------------------------------------------------------*/
1628 {
1642 }
1645 }
1647 /* If we are erasing, remove the netlist entry from the object */
1652 }
1653 }
1655 /*----------------------------------------------------------------------*/
1656 /* Push the matrix stack for each object (instance) until the indicated */
1657 /* object is reached. This works similarly to highlightnet() above, */
1658 /* but makes calls according to the hierarchy described by the */
1659 /* pushlistptr parameter. */
1660 /* Returns the number of stack objects to pop after we're done. */
1661 /*----------------------------------------------------------------------*/
1664 {
1666 objinstptr sinst;
1674 rno++;
1675 }
1680 }
1683 }
1685 /*----------------------------------------------------------------------*/
1686 /* Determine if two netlists match. If "mode" is MATCH_EXACT, the */
1687 /* net numbers and subnet numbers must all be the same. If */
1688 /* MATCH_SUBNETS, then the subnet numbers must be the same. If */
1689 /* MATCH_SIZE, then they need only have the same number of subnets. */
1690 /*----------------------------------------------------------------------*/
1693 {
1698 // A wire (no subnets) matches a bus of 1 subnet. All others
1699 // are non-matching.
1705 }
1714 }
1716 }
1721 }
1726 /* A subnetid of < 0 indicates an unassigned bus */
1729 }
1737 }
1738 }
1740 }
1742 /*----------------------------------------------------------------------*/
1743 /* Copy the netlist structure from one netlist element to another */
1744 /*----------------------------------------------------------------------*/
1747 {
1764 }
1765 }
1766 }
1768 /*------------------------------------------------------*/
1769 /* Create a new "temporary" label object for a pin */
1770 /* This type of label is never drawn, so it doesn't */
1771 /* need font info. It is identified as "temporary" by */
1772 /* this lack of a leading font record. */
1773 /*------------------------------------------------------*/
1777 {
1784 }
1795 }
1798 }
1800 /* Add label to object's netlist and return a pointer to the */
1801 /* netlist entry. */
1804 }
1806 /*------------------------------------------------------*/
1807 /* Create a label for use in the list of global nets. */
1808 /* This label is like a temporary label (new_tmp_pin) */
1809 /* except that it is not represented in any object. */
1810 /* The string contains the verbatim contents of any */
1811 /* parameter substitutions in the original label. */
1812 /*------------------------------------------------------*/
1815 {
1816 labelptr newlabel;
1826 /* Add label to the global netlist and return a pointer to */
1827 /* the netlist entry. */
1830 }
1832 /*----------------------------------------------------------------------*/
1833 /* Create a temporary I/O pin (becomes part of netlist and also part of */
1834 /* the object itself). */
1835 /*----------------------------------------------------------------------*/
1839 {
1840 LabellistPtr lseek;
1841 objectptr pschem;
1843 /* buslist *sbus; (jdk) */
1844 /* int lbus; (jdk) */
1850 /* Primary schematic (contains the netlist) */
1853 /* Determine a netlist for this pin */
1859 }
1861 /* If there is any other pin at this location, don't make another */
1862 /* one. If there is already a temporary pin associated with the */
1863 /* net, use its name. */
1875 }
1876 /* if we've encountered a unique instance, then continue past */
1877 /* all other instances using this label. */
1881 }
1882 }
1884 }
1886 /*--------------------------------------------------------------*/
1887 /* Search for connections into a non-symbol subcircuit, based */
1888 /* on various combinations of polygon and pin label overlaps. */
1889 /*--------------------------------------------------------------*/
1892 {
1894 objinstptr tinst;
1896 polyptr tpoly;
1897 labelptr tlab;
1899 LabellistPtr tseek;
1900 PolylistPtr pseek;
1904 /* Generate temporary polygon in the coordinate system of */
1905 /* the object instance in question */
1910 /* Fprintf(stdout, "Info: translated polygon w.r.t. object %s\n", */
1911 /* cinst->thisobject->name); */
1913 /* Recursion on all appropriate sub-schematics. */
1914 /* (Use parts list, not call list, as call list may not have created yet) */
1924 }
1925 }
1926 }
1935 /* Look at the object only (symbol, or schematic if it has no symbol) */
1938 /* Search for connections to pin labels */
1945 /* Fprintf(stdout, "%s connects to pin %s of %s in %s\n", */
1946 /* ((number > 1) ? "Polygon" : "Pin"), */
1947 /* tlab->string + 2, tinst->thisobject->name, */
1948 /* cinst->thisobject->name); */
1952 }
1953 }
1954 }
1959 /* Search for connections from segments passed to this */
1960 /* function to endpoints of polygons in the netlist. */
1968 /* Create new pinlabel (only if there is not one already there) */
1973 }
1974 }
1975 }
1980 /* Search for connections from endpoints passed to this */
1981 /* function to segments of polygons in the netlist. */
1994 /* Create new pinlabel (only if there is not one already there) */
1999 }
2000 }
2001 }
2004 }
2006 /*----------------------------------------------------------------------*/
2007 /* Associate polygon with given netlist and add to the object's list */
2008 /* of network polygons (i.e., wires). */
2009 /*----------------------------------------------------------------------*/
2012 {
2013 PolylistPtr newpoly;
2014 objectptr pschem;
2015 /* buslist *sbus; (jdk) */
2016 /* int lbus, sub_bus; (jdk) */
2018 /* Netlist is in the master schematic */
2021 /* If this polygon is already in the list, then add an extra subnet */
2022 /* if necessary. */
2029 }
2031 }
2032 }
2034 /* Create a new entry and link to polygon list of this object */
2045 }
2047 /*-------------------------------------------------------------------------*/
2050 {
2054 }
2056 /*----------------------------------------------------------------------*/
2057 /* Promote a single net to a bus. The bus size will be equal to the */
2058 /* value "subnets". */
2059 /*----------------------------------------------------------------------*/
2062 {
2064 CalllistPtr calls;
2065 PortlistPtr ports;
2066 PolylistPtr plist;
2067 LabellistPtr llist;
2070 Boolean foundlabel;
2072 /* If no promotion is required, don't do anything */
2075 /* It "netfrom" is already a bus, but of different size than */
2076 /* subnets, then it cannot be changed. */
2081 }
2085 /* If "subnets" is 1, then "netfrom" can be promoted regardless. */
2086 /* Otherwise, if the "netfrom" net is used in any calls, then it */
2087 /* cannot be promoted. */
2096 }
2098 }
2108 }
2110 }
2112 /* It's possible for a label without bus notation to be attached */
2113 /* to this net. */
2124 }
2127 }
2129 /* We need to create a temp label associated with this net to */
2130 /* encompass the promoted bus size. If this bus is later attached */
2131 /* to a known bus, that bus name will be canonical. If no bus name */
2132 /* is ever assigned to the bus, this temp one will be used. */
2138 }
2139 }
2141 /*----------------------------------------------------------------------*/
2142 /* Change any part of the netlist "testlist" that matches the net IDs */
2143 /* of "orignet" to the net IDs of "newnet". It is assumed that the */
2144 /* lengths and sub-bus numbers of "orignet" and "newnet" match. */
2145 /*----------------------------------------------------------------------*/
2149 {
2158 }
2163 }
2168 }
2173 }
2181 }
2183 /* Promote testlist to a bus subnet of size 1 */
2190 }
2191 }
2192 }
2195 /* If the sub-bus numbers match, then change the net */
2196 /* ID to the new net number. If the sub-bus is */
2197 /* unnamed (has no associated bus-notation label), */
2198 /* then it can take on the net and subnet numbers. */
2207 }
2213 /* Keep subnetid---but, does newnet need to be promoted? */
2215 }
2221 }
2222 }
2223 }
2224 }
2226 }
2228 }
2230 /*----------------------------------------------------------------------*/
2231 /* Combine two networks in an object's linked-list Netlist */
2232 /* Parameters: cschem - pointer to object containing netlist */
2233 /* orignet - original netlist to be changed */
2234 /* newnet - new netlist to be changed to */
2235 /* */
2236 /* Attempts to merge different subnets in a bus are thwarted. */
2237 /*----------------------------------------------------------------------*/
2240 {
2241 PolylistPtr plist;
2242 LabellistPtr llist;
2243 CalllistPtr calls;
2244 PortlistPtr ports;
2245 Genericlist savenet;
2248 Boolean rval;
2250 /* Trivial case; do nothing */
2253 /* Disallow an attempt to convert a global net to a local net: */
2254 /* The global net ID always dominates! */
2261 }
2263 /* Check that the lists of changes are compatible. It appears to be */
2264 /* okay to have non-matching buses (although they should not be */
2265 /* merged), as this is a valid style in which buses do not have taps */
2266 /* but the sub-buses are explicitly called out with labels. In such */
2267 /* case, the polygons of different sub-buses touch, and this routine */
2268 /* rejects them as being incompatible. */
2272 labelptr nlab;
2273 /* If only the subnet numbers don't match up, check if */
2274 /* "orignet" has a temp label. */
2279 }
2280 }
2281 else
2284 }
2286 can_merge:
2288 /* If orignet is a bus size 1 and newnet is a wire, then promote */
2289 /* newnet to a bus size 1. */
2299 }
2301 /* Make a copy of the net so we don't overwrite it */
2316 /* Because nets that have been merged away may be re-used later, */
2317 /* change the name of any temporary labels to the new net number */
2327 }
2328 }
2329 }
2330 }
2334 /* Reflect the net change in the object's call list, if it has one. */
2341 }
2348 }
2349 }
2350 }
2351 }
2352 }
2354 /* Free the copy of the bus that we made, if we made one */
2358 }
2360 /*----------------------------------------------------------------------*/
2361 /* Wrapper to netmerge() to make sure change is made both to the symbol */
2362 /* and schematic, if both exist. */
2363 /*----------------------------------------------------------------------*/
2366 {
2367 Boolean merged;
2375 }
2377 /*----------------------------------------------------------------------*/
2378 /* Remove a call to an object instance from the call list of cschem */
2379 /*----------------------------------------------------------------------*/
2382 {
2386 /* find the instance call before this one and link it to the one following */
2393 }
2398 }
2402 else
2410 }
2412 }
2414 /*----------------------------------------------------------------------*/
2415 /* Add a pin label to the netlist */
2416 /* If cschem == NULL, add the pin to the list of global pins. */
2417 /* The new label entry in the netlist gets a copy of the netlist */
2418 /* "netlist". */
2419 /*----------------------------------------------------------------------*/
2423 {
2425 objectptr pschem;
2426 /* buslist *sbus; (jdk) */
2427 /* int lbus, sub_bus; (jdk) */
2437 }
2438 }
2442 }
2444 }
2446 /* Create a new entry and link to label list of the object */
2455 /* Always put the specific (instanced) cases in front of */
2456 /* generic cases for the same label. */
2458 /* Generic case---make it the last record for this label */
2463 }
2464 }
2468 }
2472 }
2474 }
2476 /*----------------------------------------------------------------------*/
2477 /* Add a pin label to the list of global net names. */
2478 /* The new label entry in the netlist gets a copy of the netlist */
2479 /* "netlist" and a copy of label "pin" containing the *instance* value */
2480 /* of the text. */
2481 /*----------------------------------------------------------------------*/
2485 {
2491 }
2499 }
2500 }
2504 }
2506 }
2508 /* Create a new entry and link to label list of the object */
2520 }
2524 }
2526 }
2528 /*----------------------------------------------------------------------*/
2529 /* Allocate memory for the new call list element */
2530 /* Define the values for the new call list element */
2531 /* Insert new call into call list */
2532 /* The new call is at the beginning of the list. */
2533 /*----------------------------------------------------------------------*/
2536 {
2537 CalllistPtr newcall;
2538 objectptr pschem;
2540 /* Netlist is on the master schematic */
2552 }
2554 /*----------------------------------------------------------------------*/
2555 /* Add a port to the object cschem which connects net "netto" to */
2556 /* the calling object. One port is created for each net ID in "netto" */
2557 /* (which may be a bus). The port contains the net ID in the called */
2558 /* object. The port may already exist, in which case this routine does */
2559 /* nothing. */
2560 /*----------------------------------------------------------------------*/
2563 {
2567 Boolean duplicate;
2576 }
2578 /* If a port already exists for this net, don't add another one! */
2585 }
2586 else
2588 }
2591 portid++;
2599 else
2603 }
2605 }
2606 }
2608 /*----------------------------------------------------------------------*/
2609 /* Add a specific port connection from object cschem into the instance */
2610 /* cinst. This equates a net number in the calling object cschem */
2611 /* (netfrom) to a net number in the object instance being called */
2612 /* (netto). */
2613 /* */
2614 /* If we attempt to connect a bus of one size to a port of a different */
2615 /* size, return FALSE. Otherwise, add the call and return TRUE. */
2616 /*----------------------------------------------------------------------*/
2619 {
2620 CalllistPtr ccall;
2622 objectptr instobj;
2623 objinstptr cinst;
2626 Boolean duplicate;
2628 /* The call that we need to add a port to is the first on */
2629 /* the list for cschem, as created by addcall(). */
2636 /* It is possible that "netfrom" is an unlabeled polygon that */
2637 /* is implicitly declared a bus by its connection to this */
2638 /* port. If so, we promote "netfrom" to a bus but set the */
2639 /* subnet entries to negative values, since we don't know what */
2640 /* they are yet. */
2642 }
2644 /* Only other allowable condition is a bus size 1 connecting into */
2645 /* a single-wire port. However, one should consider promotion of */
2646 /* the pin in the target object to a bus on a per-instance basis. */
2647 /* This has not yet been done. . . */
2650 /* Let the caller report error information, because it knows more */
2652 }
2653 }
2666 }
2679 }
2682 }
2686 }
2688 /* Check the ports of the instance's object for the one matching */
2689 /* the "netto" net ID. */
2696 /* If there is already an entry for this port, then */
2697 /* we may need to merge nets in cschem. */
2707 }
2709 /* Upon failure, see if we can merge the other */
2710 /* direction. */
2719 }
2720 }
2721 }
2722 }
2724 }
2732 }
2734 }
2735 }
2737 }
2739 }
2741 /*----------------------------------------------------------------------*/
2742 /* Find the net ID corresponding to the indicated port ID in the */
2743 /* indicated object. */
2744 /*----------------------------------------------------------------------*/
2747 {
2748 PortlistPtr plist;
2753 }
2755 }
2757 /*----------------------------------------------------------------------*/
2758 /* Traverse netlist and return netid of polygon or pin on which the */
2759 /* indicated point is located. */
2760 /* If point is not on any polygon or does not match any pin position, */
2761 /* return NULL. */
2762 /* Labels which have a non-NULL "cinst" record are instance-dependent */
2763 /* and must match parameter "cinst". */
2764 /* */
2765 /* This routine checks to see if more than one net crosses the point */
2766 /* of interest, and merges the nets if found. */
2767 /* (the method has been removed and must be reinstated, presumably) */
2768 /*----------------------------------------------------------------------*/
2771 {
2773 PolylistPtr ppoly;
2774 LabellistPtr plab;
2778 /* cschem is the object containing the point. However, if the object */
2779 /* is a secondary schematic, the netlist is located in the master. */
2790 /* if we've encountered a unique instance, then continue past */
2791 /* all other instances using this label. */
2796 }
2798 /* Check against polygons. We use this part of the routine to see */
2799 /* if there are crossing wires on top of a port. If so, they are */
2800 /* merged together. */
2812 else
2814 }
2815 }
2816 }
2819 }
2821 /*----------------------------------------------------------------------*/
2822 /* localpin keeps track of temporary pin labels when flattening the */
2823 /* hierarchy without destroying the original pin names. */
2824 /*----------------------------------------------------------------------*/
2827 {
2828 NetnamePtr netnames;
2834 /* Copy all net names which are passed from above through ports */
2843 }
2844 }
2856 }
2857 }
2858 }
2860 /*----------------------------------------------------------------------*/
2861 /* Find the first point associated with the net "netid" in the object */
2862 /* cschem. */
2863 /*----------------------------------------------------------------------*/
2866 {
2867 PolylistPtr plist;
2868 LabellistPtr llist;
2877 }
2881 }
2884 }
2886 }
2887 }
2894 }
2898 }
2901 }
2903 }
2904 }
2906 }
2908 /*----------------------------------------------------------------------*/
2909 /* Find a label element for the given net number. In a symbol, this */
2910 /* will be the label representing the pin (or the first one found, if */
2911 /* the pin has multiple labels). If no label is found, return NULL. */
2912 /* Preferably choose a non-temporary label, if one exists */
2913 /*----------------------------------------------------------------------*/
2916 {
2917 LabellistPtr llist;
2928 }
2932 }
2938 }
2940 }
2941 }
2943 }
2946 /*----------------------------------------------------------------------*/
2947 /* Find the subnet number of the given net. This routine should be */
2948 /* used only as a last resort in case the subnet number is not */
2949 /* available; it has to look through the polygon and label lists in */
2950 /* detail to find the specified net ID. */
2951 /*----------------------------------------------------------------------*/
2954 {
2955 PolylistPtr plist;
2956 LabellistPtr llist;
2966 }
2971 }
2974 }
2976 }
2977 }
2985 }
2990 }
2993 }
2995 }
2996 }
2998 }
3000 /*----------------------------------------------------------------------*/
3001 /* Find a pin name for the given net number */
3002 /* Either take the last pin name with the net, or generate a new pin, */
3003 /* assigning it a net number for a string. */
3004 /* prefix = NULL indicates spice netlist, but is also used for PCB-type */
3005 /* netlists because the calling hierarchy is generated elsewhere. */
3006 /*----------------------------------------------------------------------*/
3009 {
3010 NetnamePtr netname;
3011 labelptr pinlab;
3012 LabellistPtr netlabel;
3016 /* buslist *sbus; (jdk) */
3017 Genericlist newnet;
3020 /* prefix is NULL for hierarchical (spice) netlists and for */
3021 /* internal netlist manipulation. */
3027 /* If this is a "temp label", regenerate the name according to */
3028 /* the actual net number, if it does not match. This prevents */
3029 /* unrelated temp labels from getting the same name. */
3040 }
3041 }
3042 }
3044 }
3046 /* If there's no label associated with this network, make one */
3047 /* called "intn" where n is the net number (netid). This is a */
3048 /* temp label (denoted by lack of a font specifier). */
3055 }
3056 }
3058 /* Flattened (e.g., sim) netlists */
3065 }
3066 }
3068 /* Generate the string for the local instantiation of this pin */
3069 /* If this node does not have a pin, create one using the current */
3070 /* hierarchy prefix as the string. */
3076 }
3080 }
3084 }
3089 }
3091 /* "newstring" is allocated only once and should not be free'd */
3092 /* by the calling routine. */
3098 }
3101 }
3104 }
3106 /*----------------------------------------------------------------------*/
3107 /* Find the net which connects to the given pin label */
3108 /* Return NULL (no net) if no match was found. */
3109 /*----------------------------------------------------------------------*/
3112 {
3113 LabellistPtr seeklabel;
3118 /* check against local pins, if this pin is declared local */
3125 {
3126 /* Quick simple case: no bus */
3132 /* It is necessary to be able to put together a netlist from */
3133 /* partial sources none of which may be complete. */
3146 matched++;
3147 }
3151 }
3152 }
3153 }
3158 }
3160 }
3162 #ifdef TCL_WRAPPER
3164 /*----------------------------------------------------------------------*/
3165 /* Automatic Schematic Generation stuff--- */
3166 /* Blow away all polygons in the schematic and replace them with a */
3167 /* simple rat's-nest (point-to-point). */
3168 /* */
3169 /* This routine is more of a proof-of-concept than a useful routine, */
3170 /* intended to be called only from the Tcl console. It is intended to */
3171 /* reveal most of the issues related to automatic schematic generation, */
3172 /* in which the netlist, or a portion of it, can be redrawn as objects */
3173 /* are moved around to maintain the relationships present in the */
3174 /* calls structure. */
3175 /*----------------------------------------------------------------------*/
3178 {
3179 CalllistPtr calls;
3180 PortlistPtr ports;
3181 PolylistPtr plist;
3182 LabellistPtr llist;
3184 objinstptr cinst;
3188 XPoint portpos;
3189 Boolean result;
3194 /* Go through the netlist and remove all polygons. Remove */
3195 /* the polygons from the object as well as from the netlist. */
3200 }
3203 /* for each schematic (PRIMARY or SECONDARY), remove the tagged */
3204 /* elements. */
3211 }
3214 }
3216 /* Now, for each net ID in the label list, run through the calls and */
3217 /* find all points in the calls connecting to that net. Link */
3218 /* them with as many polygons as needed. These polygons are point- */
3219 /* to-point lines, turning the schematic representation into a */
3220 /* "rat's-nest". */
3227 }
3232 }
3237 /* Determine schematic object from the object called. Start a */
3238 /* new polygon any time we switch schematic pages. */
3247 /* Find the location of this port in the coordinates of cschem */
3251 points++;
3258 }
3259 else
3261 }
3264 /* Deal with error condition? */
3265 }
3266 }
3267 }
3268 }
3270 }
3271 }
3273 /* Now, move all the labels to reconnect to their networks */
3275 /* (to be done) */
3277 /* Refresh the screen */
3279 }
3281 #endif
3283 /*----------------------------------------------------------------------*/
3284 /* Find a net or netlist in object cschem with the indicated name. */
3285 /* */
3286 /* This is the same routine as above, but finds the net with the given */
3287 /* name, or all nets which are a subset of the given name, if the name */
3288 /* is the name of a bus. Return NULL if no match was found. */
3289 /*----------------------------------------------------------------------*/
3292 {
3293 LabellistPtr seeklabel;
3294 stringpart newstring;
3296 /* Build a simple xcircuit string from "netname" (nothing malloc'd) */
3301 /* Check against local networks */
3307 /* Check against global networks */
3314 }
3316 /*----------------------------------------------------------------------*/
3317 /* Check if two parts may have the same component index. This is true */
3318 /* for parts with parameterized pins, such as those in the "quadparts" */
3319 /* library. Compare the names of the ports in each instance. If none */
3320 /* match, then these are unique subparts of a single component, and we */
3321 /* should return FALSE. Otherwise, return TRUE. */
3322 /*----------------------------------------------------------------------*/
3325 {
3326 PortlistPtr port;
3327 labelptr plab;
3329 Boolean rvalue;
3341 }
3343 }
3345 /*----------------------------------------------------------------------*/
3346 /* Generate an index number for a device in a flat netlist format. */
3347 /* We ignore any values given to "index" (this is a to-do item, since */
3348 /* many schematics are only a single level of hierarchy, so it makes */
3349 /* sense to keep designated indices when possible), but do generate */
3350 /* independent index numbering for different device classes. */
3351 /*----------------------------------------------------------------------*/
3354 {
3359 }
3361 }
3368 }
3370 /*----------------------------------------------------------------------*/
3371 /* Free the list of per-class flat device indices */
3372 /*----------------------------------------------------------------------*/
3375 {
3381 }
3383 }
3385 /*---------------------------------------------------------*/
3386 /* Convert a number (up to 99999) to its base-36 equivalent */
3387 /*---------------------------------------------------------*/
3390 {
3403 }
3405 /*----------------------------------------------------------------------*/
3406 /* Generate an index number for this device. Count all devices having */
3407 /* the same device name (as printed in the netlist) in the calls of */
3408 /* the calling object (cfrom) */
3409 /* */
3410 /* Update (9/29/04): Remove any leading whitespace from the device */
3411 /* name to prevent treating, for example, "J?" and " J?" as separate */
3412 /* device types. */
3413 /* */
3414 /* Update (7/28/05): To allow SPICE device indices to include all */
3415 /* alphanumerics, we parse in base-36, and count in the subset of */
3416 /* base-36 that can be interpreted as decimal (1-9, 36-45, etc.) */
3417 /*----------------------------------------------------------------------*/
3420 {
3425 /* oparamptr ops; (jdk) */
3433 /* Count total number of devices */
3446 }
3447 }
3457 }
3462 }
3464 /*----------------------------------------------------------------------*/
3465 /* Generate and return a list of all info label prefixes in a design */
3466 /* This does not depend on the netlist being generated (i.e., does not */
3467 /* use CalllistPtr) */
3468 /*----------------------------------------------------------------------*/
3471 {
3474 labelptr plabel;
3475 objinstptr cinst;
3477 slistptr modeptr;
3498 }
3499 }
3500 }
3506 }
3507 }
3508 }
3510 /*----------------------------------------------------------------------*/
3511 /* Create and return an ordered list of info labels for the schematic */
3512 /* page cschem. A linked label list is returned, combining info labels */
3513 /* from all schematic pages related to cschem (master and slave pages). */
3514 /* It is the responsibility of the calling routine to free the linked */
3515 /* list. */
3516 /*----------------------------------------------------------------------*/
3519 {
3523 labelptr plabel;
3538 locpos--;
3539 }
3540 else
3551 /* Consider only positive-valued numbers. Negative */
3552 /* indices are handled by "writenet" by merging the */
3553 /* minus character into the mode name. */
3557 }
3558 else
3568 /* Order the linked list */
3573 }
3580 }
3584 }
3585 }
3586 }
3587 }
3588 }
3589 }
3591 }
3593 /*----------------------------------------------------------------------*/
3594 /* Trivial default pin name lookup. Parse an object's pin labels for */
3595 /* pin names. Return the text of the nth pin name, as counted by the */
3596 /* position in the object's parts list. If there are fewer than (n+1) */
3597 /* pin labels in the object, return NULL. Otherwise, return the pin */
3598 /* name in a malloc'd character string which the caller must free. */
3599 /*----------------------------------------------------------------------*/
3602 {
3604 labelptr plabel;
3616 }
3617 count++;
3618 }
3619 }
3620 }
3622 }
3624 /*----------------------------------------------------------------------*/
3625 /* Parse an object's info labels for pin names. This is *not* a */
3626 /* netlist function. The nth pin name is returned, or NULL if not */
3627 /* found. Return value is a malloc'd string which the caller must */
3628 /* free. */
3629 /*----------------------------------------------------------------------*/
3632 {
3634 labelptr plabel;
3650 }
3651 /* Currently we are not checking against "mode". . .*/
3652 /* interpret all characters after the colon */
3658 /* Do for all text characters */
3661 strt++;
3662 i++;
3665 strt++;
3671 }
3672 count++;
3673 }
3674 }
3675 }
3676 }
3677 }
3678 }
3679 }
3681 }
3683 /*----------------------------------------------------------------------*/
3684 /* Look for information labels in the object parts list. Parse the */
3685 /* information labels and print results to specified output device. */
3686 /* (This is not very robust to errors---needs work!) */
3687 /* */
3688 /* If "autonumber" is true, then the parsed info label is used to */
3689 /* auto-number devices. */
3690 /*----------------------------------------------------------------------*/
3694 {
3695 /* genericptr *pgen; (jdk) */
3699 PortlistPtr ports;
3703 u_int newindex;
3710 /* For flat netlists, prefix the mode with the word "flat". */
3711 /* As of 3/8/07, this includes the ".sim" format, which */
3712 /* should be called as mode "flatsim". */
3718 }
3720 /* mode == "" is passed when running resolve_devindex() and indicates */
3721 /* that the routine should be used to assign devindex to calls whose */
3722 /* devices have been manually assigned numbers. The preferred method */
3723 /* is to assign these values through the "index" parameter. Use of */
3724 /* parseinfo() ensures that objects that have no "index" parameter */
3725 /* but have valid info-labels for SPICE or PCB output will be */
3726 /* assigned the correct device index. */
3727 /* Sept. 3, 2006---The use of the prepended "@" character on */
3728 /* parameter names means that I can replace the cryptic "idx" with */
3729 /* the more obvious "index", which previously conflicted with the */
3730 /* PostScript command of the same name. Parameters "index" and "idx" */
3731 /* are treated interchangeably by the netlister. */
3736 /* 1st pass: look for valid labels; see if more than one applies. */
3737 /* If so, order them correctly. Labels may not be numbered in */
3738 /* sequence, and may begin with zero. We allow a lot of flexibility */
3739 /* but the general expectation is that sequences start at 0 or 1 and */
3740 /* increase by consecutive integers. */
3744 /* Now parse each label in sequence and output the result to */
3745 /* the return string. */
3755 /* move to colon character */
3760 }
3762 /* interpret all characters after the colon */
3767 /* Do for all text characters */
3771 strt++;
3772 i++;
3792 else
3797 }
3808 else
3827 /* drop through */
3831 /* Followed by a filename to include verbatim into */
3832 /* the output. Filename either has no spaces or */
3833 /* is in quotes. */
3835 /* Use textprint to catch any embedded parameters */
3845 }
3846 strt++;
3847 }
3850 /* No filename; print verbatim */
3854 }
3861 fnsh++;
3867 /* Do variable and tilde expansion on the filename */
3871 /* Check if this file has been included already */
3876 }
3878 }
3880 /* Open the indicated file and dump to the output */
3892 }
3894 }
3897 }
3902 /* Pin name either has no spaces or is in quotes */
3903 strt++;
3906 strt++;
3907 i++;
3908 }
3912 fnsh++;
3916 /* if (is_quoted || *fnsh == '\0') i++; */
3919 /* Find the port which corresponds to this pin name */
3920 /* in the called object (cschem). If this is a */
3921 /* linked symbol/schematic, then the port list will */
3922 /* be in the schematic view, not in the symbol view */
3934 // NOTE: _STR is used inside textprintsubnet()
3940 }
3941 else
3943 }
3946 /* Find the matching port in the calling object instance */
3962 }
3965 }
3966 }
3969 }
3972 /* Parameter name either has no spaces or is in quotes */
3973 strt++;
3976 strt++;
3977 i++;
3978 }
3982 fnsh++;
3986 /* if (is_quoted || *fnsh == '\0') i++; */
3989 /* Compare this name against the parameter keys */
3992 /* For backwards compatibility, also try matching against */
3993 /* the parameter default value (method used before */
3994 /* implementing parameters as key:value pairs). */
4000 /* substitute the parameter or default */
4009 }
4011 }
4012 }
4013 }
4014 }
4019 }
4023 /* Presence of ".ends" statement forces xcircuit */
4024 /* not to write ".end" at the end of the netlist. */
4033 }
4034 }
4040 /* Parameters with unresolved question marks are treated */
4041 /* like a "%i" string. */
4047 else
4053 }
4055 /* When called with autonumber = TRUE, generate a parameter */
4056 /* instance, replacing the question mark with the new index */
4057 /* number. */
4067 }
4070 }
4071 }
4073 /* A "?" default parameter that has a (different) */
4074 /* instance value becomes the device number. */
4079 CalllistPtr plist;
4082 /* Ignore the value and generate one instead */
4090 }
4093 /* Interpret parameter string as a component */
4094 /* number so we can check for duplicates. Assume */
4095 /* a base-36 number, which includes all alphabet */
4096 /* characters. This will disambiguate, e.g., "1" */
4097 /* and "1R", but flag case-sensitivity, e.g., */
4098 /* "1R" and "1r". Thanks to Carsten Thomas for */
4099 /* pointing out the problem with assuming */
4100 /* numerical component values. */
4107 }
4113 /* Two parts have been named the same. Flag */
4114 /* it, but don't try to do anything about it. */
4115 /* 11/22/06---additionally check part numbers, */
4116 /* in case the symbol is a component sub-part. */
4123 }
4124 }
4125 }
4126 }
4127 }
4128 }
4129 }
4133 /* By convention, greek "mu" becomes ASCII "u", NOT "m", */
4134 /* otherwise we get, e.g., millifarads instead of microfarads */
4138 else
4141 }
4142 }
4143 }
4145 /* Some label controls are interpreted. Most are ignored */
4166 }
4167 }
4168 }
4170 /* Insert a newline between multiple valid info labels */
4174 }
4175 }
4181 }
4183 }
4185 /*----------------------------------------------------------------------*/
4186 /* Write a low-level device */
4187 /*----------------------------------------------------------------------*/
4191 {
4193 objectptr cthis;
4198 }
4200 /* Devices are always symbols. If the call indicates a schematic */
4201 /* and a separate associated symbol, then we want the symbol. */
4202 /* If we're writing a flat netlist, then return -1 to indicate that */
4203 /* the symbol instance needs to be flattened. */
4207 SECONDARY)
4211 else
4213 }
4215 /* Look for information labels in the object parts list. */
4221 }
4224 }
4226 /* Information labels do not necessarily exist. */
4228 }
4230 #ifdef TCL_WRAPPER
4232 /*----------------------------------------------------------------------*/
4233 /* Translate a hierarchical net name into an object and instance. */
4234 /* Return TRUE if found, FALSE if not. If found, object and instance */
4235 /* are returned in the argument pointers. */
4236 /*----------------------------------------------------------------------*/
4239 {
4240 CalllistPtr calls;
4243 objinstptr newinst;
4245 /* pushlistptr stackentry; (jdk) */
4254 }
4255 }
4266 }
4267 else
4269 }
4272 /* check to make sure that the netlist and device indices have been generated */
4277 }
4278 }
4280 /* hptr is now the object name, and devindex is the instance's call index */
4281 /* find the object corresponding to the name. */
4287 /* Try device names (for netlist output) instead of object names */
4296 }
4300 }
4301 }
4302 }
4303 }
4304 }
4309 }
4314 }
4316 /* Diagnostic information */
4317 /* fprintf(stderr, "object %s(%d) = %s\n", newobj->name, devindex, hptr); */
4326 }
4328 }
4330 #endif
4332 /*----------------------------------------------------------------------*/
4333 /* Save netlist into a flattened sim or spice file */
4334 /*----------------------------------------------------------------------*/
4337 {
4341 /* reset device indexes */
4346 /* The naming convention for nodes below the top level uses a */
4347 /* slash-separated list of hierarchical names. Thus the call to */
4348 /* the hierarchical resolve_indices(). Indices used by bottom-most */
4349 /* symbols (e.g., flattened spice) will be generated by a separate */
4350 /* routine devflatindex(), unrelated to what is generated here, */
4351 /* which only affects the hierarchical naming of nodes. */
4355 /* write all the subcircuits */
4366 /* Allow cross-referenced parameters between symbols and schematics */
4367 /* by substituting into a schematic from its corresponding symbol */
4369 /* psubstitute(calls->callinst); */
4371 }
4373 }
4375 }
4377 /*----------------------------------------------------------------------*/
4378 /* Topmost call to write a flattened netlist */
4379 /*----------------------------------------------------------------------*/
4383 {
4386 Calllist loccalls;
4388 /* Set up local call list for parsing info labels in the top-level schematic */
4401 /* "<mode>@" lines go in front */
4405 FALSE);
4411 }
4416 /* Check for negative-numbered info labels, indicated output that */
4417 /* should be processed after everything else. */
4426 }
4428 }
4430 /*----------------------------------------------------------------------*/
4431 /* Write out the list of global nets and their pin names */
4432 /*----------------------------------------------------------------------*/
4435 {
4436 LabellistPtr llist;
4437 labelptr gpin;
4448 }
4450 }
4452 /*----------------------------------------------------------------------*/
4453 /* Write a SPICE subcircuit entry. */
4454 /*----------------------------------------------------------------------*/
4457 {
4458 PortlistPtr ports;
4463 /* Objects which have no ports are not written */
4469 /* List of parameters in subcircuit. */
4470 /* Each parameter connects to a net which may have multiple */
4471 /* names, so find the net associated with the parameter */
4472 /* and convert it back into a pin name in the usual manner */
4473 /* using nettopin(). */
4485 }
4489 }
4491 }
4492 }
4494 /*----------------------------------------------------------------------*/
4495 /* Resolve device names (fill calllist structure member "devname") */
4496 /*----------------------------------------------------------------------*/
4499 {
4500 CalllistPtr calls;
4502 oparamptr ops;
4508 }
4512 /* Check for "class" parameter. Note that although this */
4513 /* parameter may take a different instance value, the */
4514 /* device class is determined by the default value. */
4520 /* The slow way---parse info labels for any device information */
4524 }
4525 }
4526 }
4527 }
4529 /*----------------------------------------------------------------------*/
4530 /* Resolve (hierarchical) component numbering. If "autonumber" is TRUE */
4531 /* then this routine does auto-numbering. Otherwise, it auto-generates */
4532 /* device indices internally (in the "calllist" structure) but does not */
4533 /* copy them into parameter space. */
4534 /* */
4535 /* Note: resolve_devindex() only operates on a single object. Use */
4536 /* resolve_indices() to operate on the entire hierarchy. */
4537 /*----------------------------------------------------------------------*/
4540 {
4541 CalllistPtr calls;
4545 objinstptr cinst;
4551 /* Check if there is an "index" parameter set to "?" in */
4552 /* the object with no existing instance value. */
4570 }
4575 /* Not a simple string. Dump the text. */
4580 }
4583 }
4585 /* It is possible to get an instance value that is */
4586 /* the same as the default, although this normally */
4587 /* doesn't happen. If it does, quietly remove the */
4588 /* unneeded instance value. */
4592 else
4598 }
4599 else
4601 }
4604 }
4605 }
4606 }
4608 /* The slow way---parse info labels for any index information */
4612 }
4613 }
4614 }
4616 /*----------------------------------------------------------------------*/
4617 /* Recursive call to resolve_devindex() through the circuit hierarchy */
4618 /*----------------------------------------------------------------------*/
4621 CalllistPtr calls;
4627 }
4628 }
4630 }
4632 /*----------------------------------------------------------------------*/
4633 /* Recursive call to clear all generated device numbers. */
4634 /*----------------------------------------------------------------------*/
4637 CalllistPtr calls;
4643 }
4645 }
4646 }
4648 /*----------------------------------------------------------------------*/
4649 /* Recursive call to clear all device indexes (parameter "index") */
4650 /*----------------------------------------------------------------------*/
4653 CalllistPtr calls;
4662 }
4672 }
4673 }
4674 }
4675 }
4677 /*----------------------------------------------------------------------*/
4678 /* Save netlist into a hierarchical file */
4679 /*----------------------------------------------------------------------*/
4683 {
4689 Calllist loccalls;
4693 /* Set up local call list for parsing info labels in this schematic */
4706 /* "<mode>@" lines go before any subcircuit calls */
4710 FALSE);
4716 }
4718 /* Subcircuits which make no calls or have no devices do not get written */
4722 /* Make sure that all the subcircuits have been written first */
4729 }
4730 }
4734 }
4735 }
4737 /* Info-labels on a schematic (if any) get printed out first */
4743 /* Check stsave for embedded SPICE subcircuit syntax */
4753 }
4755 /* top-level schematics will be ignored because they have no ports */
4757 }
4759 /* Resolve all fixed part assignments (devindex) */
4762 /* If the output file is NULL, then we're done */
4767 }
4771 /* writedevice() is just another call to parseinfo() */
4774 /* If the device did not produce any output in writedevice(), but */
4775 /* does not make any calls itself, then it is implicitly a TRIVIAL */
4776 /* symbol. */
4781 /* No syntax indicating how to write this call. Use SPICE "X" */
4782 /* format and arrange the parameters according to the structure. */
4789 /* The object's definition lists calls in the order of the object's */
4790 /* port list. Therefore, use this order to find the port list. */
4791 /* This will also deal with the fact that not every port has to be */
4792 /* called by the instance (ports may be left disconnected). */
4809 }
4813 }
4817 }
4818 }
4820 /* Check for negative-numbered info labels, indicated output that */
4821 /* should be processed after everything else. If we're processing */
4822 /* SPICE output but the schematic does not provide a ".ends" */
4823 /* statement, then add it to the end of the deck. */
4836 }
4841 }
4844 }
4846 /*----------------------------------------------------------------------*/
4847 /* Create generic netlist in the Tcl interpreter variable space */
4848 /*----------------------------------------------------------------------*/
4850 #ifdef TCL_WRAPPER
4853 {
4855 labelptr plabel;
4865 }
4866 }
4867 }
4869 }
4871 /*----------------------------------------------------------------------*/
4872 /* Write global variables to Tcl list (in key-value pairs which can be */
4873 /* turned into an array variable using the "array set" command) */
4874 /* */
4875 /* Note: argument "cinst" is unused, but it really should be. We */
4876 /* should not assume that different schematics have the same list of */
4877 /* globals! */
4878 /*----------------------------------------------------------------------*/
4881 {
4882 LabellistPtr llist;
4883 labelptr gpin;
4895 }
4899 }
4902 }
4903 }
4905 }
4907 /*----------------------------------------------------------------------*/
4908 /* Write a generic hierarchical netlist into Tcl list "subcircuits" */
4909 /*----------------------------------------------------------------------*/
4912 {
4921 /* Trivial objects are by definition those that are supposed */
4922 /* to be resolved by the netlist generation prior to output */
4923 /* and ignored by the output generator. */
4927 /* Make sure that all the subcircuits have been written first */
4933 }
4934 }
4936 /* Write own subcircuit netlist */
4939 /* Prepare the list of network cross-references */
4942 /* Make list of the nets which have been written so we don't redundantly */
4943 /* list any entries (use of calloc() initializes all entries to FALSE). */
4944 /* (calloc() replaced by malloc() and bzero() because Tcl doesn't */
4945 /* have a calloc() function (2/6/04)) */
4948 #ifdef _MSC_VER
4950 #else
4952 #endif
4954 /* Write the name (key value pair) */
4959 /* Write the handle of the object instance (key value pair) */
4963 /* Write the list of ports */
4966 /* List of ports in subcircuit. */
4967 /* Each parameter connects to a net which may have multiple */
4968 /* names, so find the net associated with the parameter */
4969 /* and convert it back into a pin name in the usual manner */
4970 /* using nettopin(). */
4981 {
4985 /* record this net as having been added to the list */
4987 }
4988 }
4991 }
4993 /* Write the list of parameter defaults (key:value pairs) */
5012 /* Should get rid of last entry, "End Parameter"; not needed */
5019 }
5020 }
5023 }
5025 /* Write the list of calls to subcircuits */
5031 /* Don't write calls to non-functional subcircuits. */
5041 /* Log any local parameter instances */
5066 }
5067 }
5071 }
5073 /* Called ports are listed by key:value pair (port number: net id) */
5091 {
5095 /* record this net as having been added to the list */
5097 }
5098 }
5102 }
5104 }
5107 }
5110 /* If the object has info labels, write a device list. */
5111 /* Check both the schematic and its symbol for info labels. */
5117 }
5123 /* Write the network cross-reference dictionary */
5128 }
5130 /*----------------------------------------------------------------------*/
5133 {
5141 }
5145 /*----------------------------------------------------------------------*/
5146 /* Create generic netlist in the Python interpreter variable space */
5147 /*----------------------------------------------------------------------*/
5149 #ifdef HAVE_PYTHON
5152 {
5154 labelptr plabel;
5163 }
5164 }
5166 }
5168 /*----------------------------------------------------------------------*/
5169 /* Write global variables to Python dictionary */
5170 /*----------------------------------------------------------------------*/
5173 {
5174 LabellistPtr llist;
5175 labelptr gpin;
5189 }
5193 }
5194 }
5196 }
5198 /*----------------------------------------------------------------------*/
5199 /* Write a generic hierarchical netlist into Python list "subcircuits" */
5200 /*----------------------------------------------------------------------*/
5203 {
5209 oparamptr paramlist;
5211 /* Trivial objects are by definition those that are supposed */
5212 /* to be resolved by the netlist generation prior to output */
5213 /* and ignored by the output generator. */
5217 /* Make sure that all the subcircuits have been written first */
5223 }
5224 }
5226 /* Write own subcircuit netlist */
5229 /* Prepare the dictionary of network cross-references */
5232 /* Write the name */
5236 /* Write the list of ports */
5239 /* List of ports in subcircuit. */
5240 /* Each parameter connects to a net which may have multiple */
5241 /* names, so find the net associated with the parameter */
5242 /* and convert it back into a pin name in the usual manner */
5243 /* using nettopin(). */
5253 }
5255 }
5257 /* Write the list of parameters */
5271 /* Should get rid of last entry, "End Parameter"; not needed */
5273 }
5274 }
5276 }
5278 /* Write the list of calls to subcircuits */
5284 /* Don't write calls to non-functional subcircuits. */
5291 /* Log any local parameter instances */
5306 }
5308 pyparams);
5309 }
5311 /* The object's definition lists calls in the order of the object's */
5312 /* port list. Therefore, use this order to find the port list. */
5313 /* Unconnected ports will be NULL entries in the list (?). */
5331 }
5333 }
5335 }
5337 }
5339 /* If the object has info labels, write a device list. */
5340 /* Check both the schematic and its symbol for info labels. */
5346 }
5351 /* Write the network cross-reference dictionary */
5355 }
5357 /*----------------------------------------------------------------------*/
5360 {
5367 }
5371 /*----------------------------------------------------------------------*/
5372 /* Update networks in an object by checking if the network is valid, */
5373 /* and destroying and recreating the network if necessary. */
5374 /* */
5375 /* Run cleartraversed() on all types. The traversed flag allows a */
5376 /* check for infinite recursion when creating calls. */
5377 /* */
5378 /* Returns -1 on discovery of infinite recursion, 0 on failure to */
5379 /* generate a net, and 1 on success. */
5380 /*----------------------------------------------------------------------*/
5383 objectptr thisobject;
5384 objinstptr thisinst;
5387 /* Never try to generate a netlist while a file is being read, as */
5388 /* can happen if an expression parameter attempts to query a netlist */
5389 /* node. */
5398 }
5402 }
5410 }
5412 /* Note: destroy/create nets messes up the part list. Why?? */
5422 }
5423 }
5430 }
5432 }
5434 /*----------------------------------------------------------------------*/
5435 /* Generate netlist, write information according to mode, and then */
5436 /* destroy the netlist (this will be replaced eventually with a dynamic */
5437 /* netlist model in which the netlist changes according to editing of */
5438 /* individual elements, not created and destroyed wholesale) */
5439 /*----------------------------------------------------------------------*/
5442 {
5443 objectptr cschem;
5444 objinstptr thisinst;
5448 /* Calllist topcell; (jdk) */
5451 /* Always use the master schematic, if there is one. */
5455 else
5458 /* Update the netlist if this has not been done */
5463 }
5467 }
5479 }
5484 }
5486 /* Clear device indices from any previous netlist output */
5490 /* Make sure list of include-once files is empty */
5494 /* Handle different netlist modes */
5506 /* writeglobals(cschem, fp); */
5509 }
5517 }
5519 }
5527 }
5530 }
5537 }
5539 }
5546 }
5549 }
5551 /* User-defined modes beginning with the word "flat": */
5552 /* Assume a flattened netlist, and assume nothing else. */
5559 }
5561 /* User-defined modes beginning with the word "pseu": */
5562 /* Assume a flattened netlist for everything under the top level. */
5568 }
5570 /* All user-defined modes: Assume a hierarchical netlist, and */
5571 /* assume nothing else. */
5577 }
5579 /* Finish up SPICE files with a ".end" statement (if requested) */
5583 /* Finish up */
5588 }
5591 }
5593 /*----------------------------------------------------------------------*/
5594 /* Flatten netlist and save into a table of pcb-style nets */
5595 /* The routine is recursive. Each call returns TRUE if some nested */
5596 /* call generated output; this is a reasonable way to tell if we have */
5597 /* reached the bottom of the hierarchy. */
5598 /*----------------------------------------------------------------------*/
5602 {
5603 PolylistPtr plist;
5604 LabellistPtr llist;
5605 CalllistPtr calls;
5606 PortlistPtr ports;
5613 objinstptr cinst;
5617 Boolean outputcall;
5619 /* Step 1A: Go through the polygons of this object and add */
5620 /* any unvisited nets to the table. */
5629 }
5637 }
5639 }
5652 /* Fprintf(stdout, "Added new index entry for net %d\n", testnet); */
5653 }
5655 }
5656 }
5658 /* Step 1B: Do the same thing for labels. */
5667 }
5675 }
5677 }
5690 /* Fprintf(stdout, "Added new index entry for net %d\n", testnet); */
5691 }
5693 }
5694 }
5696 /* Step 2: Resolve fixed device indices */
5699 /* Step 3: Go through the list of calls to search for endpoints */
5702 objectptr cthis;
5706 /* Trivial objects should have been dealt with already. */
5707 /* If we don't continue the loop here, you get netlist output for */
5708 /* objects like dots and circles. */
5711 /* Step 4: If call is to a bottom-most schematic, output the device connections */
5712 /* Info-label can provide an alternate name or specify the instance number */
5716 SECONDARY)
5724 }
5727 }
5732 /*----------------------------------------------------------------*/
5733 /* Parsing of the "pcb:" info label--- */
5734 /* Find all <net>=<name> strings and create the appropriate nets */
5735 /*----------------------------------------------------------------*/
5748 rhs++;
5755 /* Get the net from the equation RHS. If none exists, assume */
5756 /* the name is a global net and add it to the list of globals. */
5761 label templabel;
5772 }
5774 /* Get the name of the pin */
5780 /* Find the net in the ptable, or create a new entry for it */
5789 }
5791 }
5805 }
5807 /* Check if any entries are the same as tmppinname */
5811 }
5812 }
5814 /* Get the pin name from the equation LHS */
5823 }
5826 }
5828 /* Proceed to the next LHS=RHS pair */
5831 }
5833 }
5838 /* Step 4A: Push current net translations */
5839 /* (Don't push or pop global net numbers: no translation needed!) */
5850 }
5852 }
5854 /* Step 4B: Generate net translation table for each subcircuit */
5864 }
5869 }
5870 }
5871 }
5876 else
5880 /* Translate net value */
5885 /* Fprintf(stdout, "Translation: net %d in object %s is net "
5886 "%d in object %s\n", ports->netid, cschem->name,
5887 locnet, calls->callobj->name); */
5888 }
5889 }
5891 /* Step 4C: Run routine recursively on the subcircuit */
5892 /* If it had a "pcb:" info label that was handled, then ignore */
5894 /* Fprintf(stdout, "Recursive call of writepcb() to %s\n",
5895 calls->callobj->name); */
5899 /* Step 4D: Pop the translation table */
5900 /* (Don't pop global nets (designated by negative net number)) */
5910 }
5912 }
5913 }
5918 /* Fprintf(stdout, "Reached lowest-level schematic: Finding connections\n"); */
5921 /* Global pin names should probably be ignored, not just */
5922 /* when an object is declared to be "trivial". Not sure if */
5923 /* this breaks certain netlists. . . */
5926 /* Get the name of the pin in the called object with no prefix. */
5932 /* Global nets were not translated, do not iterate through list */
5940 }
5941 }
5943 }
5948 }
5960 /* Replace slash '/' with dash '-' at bottommost level */
5968 /* diagnostic information */
5969 {
5974 ctr++;
5975 }
5976 /* Fprintf(stdout, "Logged level-%d net %d (local net %d) pin %s\n",
5977 ctr, *(locnet->netidx), *(hidx->nets->netidx + i),
5978 tmpstr->string); */
5979 }
5980 }
5981 }
5982 }
5983 }
5985 /* Step 5: Cleanup */
5989 }
5991 /*----------------------------------------------------------------------*/
5992 /* Save PCB table into pcb-style file */
5993 /*----------------------------------------------------------------------*/
5996 {
6013 }
6014 else
6023 }
6027 }
6029 }
6030 /* else fprintf(fp, "NET%d *UNCONNECTED*\n", netidx++); */
6031 }
6032 }
6034 /*----------------------------------------------*/
6035 /* free memory allocated to PCB net tables */
6036 /*----------------------------------------------*/
6039 {
6057 }
6066 }
6070 }
6071 }
6073 /*----------------------------------------------------------------------*/
6074 /* Remove an element from the netlist. This is necessary when an */
6075 /* element is deleted from the object, so that the netlist does not */
6076 /* refer to a nonexistant element, or try to perform netlist function */
6077 /* on it. */
6078 /* */
6079 /* Return True or False depending on whether a pin was "orphaned" on */
6080 /* the corresponding schematic or symbol (if any), as this may cause */
6081 /* the class of the object (FUNDAMENTAL, TRIVIAL, etc.) to change. */
6082 /*----------------------------------------------------------------------*/
6085 {
6087 labelptr nlab;
6088 polyptr npoly;
6089 objectptr pschem;
6090 objinstptr ninst;
6102 /* If this is an object instance, remove it from the calls */
6108 else
6113 }
6114 else
6116 }
6123 /* If this is a polygon, remove it from the netlist */
6129 else
6134 }
6135 else
6137 }
6144 /* If this is a label, remove it from the netlist */
6150 else
6155 }
6156 else
6158 }
6160 /* Mark pin label in corresponding schematic/symbol as "orphaned" */
6161 /* by changing designation from type "pin" to type "label". */
6166 }
6167 }
6169 }
6171 /*----------------------------------------------------------------------*/
6172 /* Remove one element from the netlist */
6173 /*----------------------------------------------------------------------*/
6177 objectptr pschem;
6183 /* Always call on the primary schematic */
6188 /* remove polygon from polygon list */
6199 else
6202 }
6203 else
6206 }
6211 /* remove label from label list */
6222 else
6225 }
6226 else
6229 }
6231 /* also check the globals */
6242 else
6245 }
6246 else
6249 }
6254 /* remove instance from call list */
6263 else
6265 }
6266 else
6269 }
6271 }
6274 }
6276 /*----------------------------------------------------------------------*/
6277 /* Free memory allocated for the ports in a calls. */
6278 /*----------------------------------------------------------------------*/
6281 {
6288 }
6291 }
6293 /*----------------------------------------------------------------------*/
6294 /* Free memory for a Genericlist structure (may also be a Labellist or */
6295 /* Polylist structure). */
6296 /*----------------------------------------------------------------------*/
6299 {
6304 }
6306 /*----------------------------------------------------------------------*/
6307 /* Free memory allocated for the label list in a netlist. */
6308 /*----------------------------------------------------------------------*/
6311 {
6318 }
6320 }
6322 /*----------------------------------------------------------------------*/
6323 /* Free memory allocated for the polygon list in a netlist. */
6324 /*----------------------------------------------------------------------*/
6327 {
6334 }
6336 }
6338 /*----------------------------------------------------------------------*/
6339 /* Free memory allocated for netlist */
6340 /*----------------------------------------------------------------------*/
6343 {
6351 }
6353 /*----------------------------------------------------------------------*/
6354 /* Clear the "traversed" flag in all objects of the hierarchy. */
6355 /*----------------------------------------------------------------------*/
6358 {
6360 objinstptr cinst;
6363 /* Always call on the primary schematic */
6366 /* Recursively call cleartraversed() on all subobjects, a la gennetlist() */
6367 /* Use the parts list of the object, not the calls, because calls */
6368 /* may have been removed. */
6378 else
6381 /* Don't infinitely recurse if object is on its own schematic */
6382 /* However, we need to take a stab at more subtle recursion, too */
6387 }
6388 }
6392 }
6394 /*----------------------------------------------------------------------*/
6395 /* This is the routine normally called, as it hides the "level" */
6396 /* argument tagging the level of recursion. */
6397 /*----------------------------------------------------------------------*/
6401 }
6403 /*----------------------------------------------------------------------*/
6404 /* If any part of the netlist is invalid, destroy the entire netlist */
6405 /*----------------------------------------------------------------------*/
6408 {
6410 objinstptr cinst;
6413 /* If the object has been declared a non-network object, ignore it */
6416 /* Always operate on the master schematic */
6419 /* Stop immediately if the netlist is invalid */
6422 /* Otherwise, recursively call checkvalid() on all subobjects. */
6423 /* Use the parts list of the object, not the calls, because calls */
6424 /* may have been removed. */
6432 else
6435 /* Don't infinitely recurse if object is on its own schematic */
6439 /* If there is a symbol, don't check its parts, but check if */
6440 /* its netlist has been checkvalid. */
6448 /* Recursive call on subschematic */
6451 }
6452 }
6454 }
6456 /*----------------------------------------------------------------------*/
6457 /* Free memory allocated to temporary labels generated for the netlist */
6458 /*----------------------------------------------------------------------*/
6461 {
6463 objinstptr cinst;
6464 objectptr callobj;
6466 /* Recursively call freetemplabels() on all subobjects, a la gennetlist() */
6467 /* Use the parts list of the object, not the calls, because calls */
6468 /* may have been removed. */
6476 else
6479 /* Don't infinitely recurse if object is on its own schematic */
6482 /* Also free the temp labels of any associated symbol */
6484 }
6486 /* Free any temporary labels which have been created */
6490 /* int tmpval = (int)(cgen - cschem->plist); (jdk) */
6500 cgen--;
6501 }
6502 }
6503 }
6504 }
6506 /*----------------------------------------------------------------------*/
6507 /* Free memory allocated for netlists, ports, and calls */
6508 /*----------------------------------------------------------------------*/
6511 {
6515 objinstptr cinst;
6516 objectptr callobj;
6518 /* Recursively call freenets() on all subobjects, a la gennetlist() */
6519 /* Use the parts list of the object, not the calls, because calls */
6520 /* may have been removed. */
6530 else
6533 /* Don't infinitely recurse if object is on its own schematic */
6536 /* Also free the netlist of any associated symbol */
6538 }
6539 }
6540 }
6542 /* Free the allocated structures for this object */
6548 }
6555 }
6565 }
6567 /*----------------------------------------------------------------------*/
6568 /* Free the global pin list */
6569 /*----------------------------------------------------------------------*/
6572 {
6578 /* Labels in the global list are temporary and must be deallocated */
6584 }
6586 }
6588 /*----------------------------------------------------------------------*/
6589 /* Get rid of locally-defined pin names */
6590 /*----------------------------------------------------------------------*/
6593 {
6600 }
6603 }
6605 }
6607 /*----------------------------------------------------------------------*/
6608 /* Handle lists of included files */
6609 /*----------------------------------------------------------------------*/
6611 /*----------------------------------------------------------------------*/
6612 /* check_included() --- check if a file has already been included. */
6613 /* Check by inode instead of filename so that we cannot trick the */
6614 /* program by giving, e.g., one relative path and one full path. */
6615 /*----------------------------------------------------------------------*/
6618 {
6626 }
6627 }
6629 }
6631 /*----------------------------------------------------------------------*/
6632 /* append_included() --- update the list of included files by adding */
6633 /* the inode of filename to the list. */
6634 /*----------------------------------------------------------------------*/
6637 {
6647 }
6656 }
6657 }
6660 }
6661 }
6663 /*----------------------------------------------------------------------*/
6666 {
6670 }
6671 }
6673 /*-------------------------------------------------------------------------*/