home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 13 / 13.iso / p / p078 / 3.img / NETFORMS.PLB / PLDNET.CF < prev    next >
Encoding:
Text File  |  1991-10-14  |  8.8 KB  |  394 lines
  1. /*
  2.     /L Do not append sheet number to labels
  3.  */
  4.  
  5. /*  VERSION="1.10   14-OCT-91"
  6.  *      - Added code for outputting missing pins on a part
  7.  *      - Added Version message
  8.  *
  9.  *  Capacities:
  10.  *      - Part Names are not checked for length
  11.  *      - Module Names are not checked for length
  12.  *      - Reference Strings are not checked for length
  13.  *      - Node Names are not checked for length
  14.  *      - Pin Numbers are not checked for length
  15.  *
  16.  *  Characters:
  17.  *      - All ASCII keyboard characters are legal
  18.  */
  19.  
  20. int prevpin;
  21. int currpin;
  22. int type;
  23.  
  24. int sw_L;
  25.  
  26. /*-----------------------*/
  27.  
  28. Initialize()
  29. {
  30.     WriteString(0, "Creating Netlist...");
  31.     WriteCrLf(0);
  32.  
  33.     AddSymbol("FieldStr");
  34.     AddSymbol("PinNumberStr");
  35.     AddSymbol("PartNameStr");
  36.     AddSymbol("Str");
  37.  
  38.     SetCharSet("0123456789");
  39.     SetNumberWidth(5);
  40.  
  41.     sw_L = SwitchIsSet("L");
  42.  
  43.     WriteString(1, "|| ");
  44.     CopySymbol(TitleString, Str);
  45.     PadSpaces(Str, 46);
  46.     WriteSymbol(1, Str);
  47.     WriteString(1, "Revised: ");
  48.     WriteSymbol(1, DateString);
  49.     WriteCrLf(1);
  50.     WriteString(1, "|| ");
  51.     CopySymbol(DocumentNumber, Str);
  52.     PadSpaces(Str, 46);
  53.     WriteSymbol(1, Str);
  54.     WriteString(1, "Revision: ");
  55.     WriteSymbol(1, Revision);
  56.     WriteCrLf(1);
  57.     WriteString(1, "|| ");
  58.     WriteSymbol(1, Organization);
  59.     WriteCrLf(1);
  60.     WriteString(1, "|| ");
  61.     WriteSymbol(1, AddressLine1);
  62.     WriteCrLf(1);
  63.     WriteString(1, "|| ");
  64.     WriteSymbol(1, AddressLine2);
  65.     WriteCrLf(1);
  66.     WriteString(1, "|| ");
  67.     WriteSymbol(1, AddressLine3);
  68.     WriteCrLf(1);
  69.     WriteString(1, "|| ");
  70.     WriteSymbol(1, AddressLine4);
  71.     WriteCrLf(1);
  72.     WriteString(1, "|| ");
  73.     WriteCrLf(1);
  74. }
  75.  
  76. /*-----------------------*/
  77.  
  78. WriteHeader()
  79. {
  80.     CreatePartDataBase();
  81. }
  82.  
  83. /*-----------------------*/
  84.  
  85. HandleNodeName()
  86. {
  87.     AddSignalName();
  88. }
  89.  
  90. /*-----------------------*/
  91.  
  92. WriteNet()
  93. {
  94.     RecordNode();
  95. }
  96.  
  97. /*-----------------------*/
  98.  
  99. WriteNetEnding()
  100. {
  101. }
  102.  
  103. /*-----------------------*/
  104.  
  105. ProcessFieldStrings()
  106. {
  107. }
  108.  
  109. /*-----------------------*/
  110.  
  111. WriteINBISignals()
  112. {
  113.     int first;
  114.     int len;
  115.     int temp;
  116.  
  117.     len = 0;
  118.  
  119.     WriteString(1, "| Netlist:  ");
  120.  
  121.     first = 1;
  122.     SetFirst(SIGNALS);
  123.     do {
  124.         type = GetStandardSymbol(TypeCode);
  125.  
  126.         if (type == 'P')
  127.         {
  128.             type = GetStandardSymbol(SignalType);
  129.             if (type == 2)
  130.             {
  131.                 if (len > 55)
  132.                 {
  133.                     len = 0;
  134.                     first = 1;
  135.  
  136.                     WriteString(1, ",");
  137.                     WriteCrLf(1);
  138.                     WriteString(1, "|           ");
  139.                 }
  140.  
  141.                 if (first != 1) { WriteString(1, ","); }
  142.                 WriteSymbol(1, SignalNameString);
  143.                 first = 0;
  144.  
  145.                 temp = SymbolLength(SignalNameString);
  146.                 len = len + temp + 1;
  147.             }
  148.  
  149.             if (type == 3)
  150.             {
  151.                 if (len > 55)
  152.                 {
  153.                     len = 0;
  154.                     first = 1;
  155.  
  156.                     WriteString(1, ",");
  157.                     WriteCrLf(1);
  158.                     WriteString(1, "|           ");
  159.                 }
  160.  
  161.                 if (first != 1) { WriteString(1, ","); }
  162.                 WriteSymbol(1, SignalNameString);
  163.                 first = 0;
  164.  
  165.                 temp = SymbolLength(SignalNameString);
  166.                 len = len + temp + 1;
  167.             }
  168.         }
  169.     } while (SetNext(SIGNALS));
  170. }
  171.  
  172. /*-----------------------*/
  173.  
  174. WriteOUTBISignals()
  175. {
  176.     int first;
  177.     int len;
  178.     int temp;
  179.  
  180.     len = 0;
  181.  
  182.     WriteString(1, "|           ");
  183.  
  184.     first = 1;
  185.     SetFirst(SIGNALS);
  186.     do {
  187.         type = GetStandardSymbol(TypeCode);
  188.         if (type == 'P')
  189.         {
  190.             type = GetStandardSymbol(SignalType);
  191.             if (type == 1)
  192.             {
  193.                 if (len > 55)
  194.                 {
  195.                     len = 0;
  196.                     first = 1;
  197.  
  198.                     WriteString(1, ",");
  199.                     WriteCrLf(1);
  200.                     WriteString(1, "|           ");
  201.                 }
  202.  
  203.                 if (first != 1) { WriteString(1, ","); }
  204.                 WriteSymbol(1, SignalNameString);
  205.                 first = 0;
  206.  
  207.                 temp = SymbolLength(SignalNameString);
  208.                 len = len + temp + 1;
  209.             }
  210.  
  211.             if (type == 3)
  212.             {
  213.                 if (len > 55)
  214.                 {
  215.                     len = 0;
  216.                     first = 1;
  217.  
  218.                     WriteString(1, ",");
  219.                     WriteCrLf(1);
  220.                     WriteString(1, "|           ");
  221.                 }
  222.  
  223.                 if (first != 1) { WriteString(1, ","); }
  224.                 WriteSymbol(1, SignalNameString);
  225.                 first = 0;
  226.  
  227.                 temp = SymbolLength(SignalNameString);
  228.                 len = len + temp + 1;
  229.             }
  230.         }
  231.     } while (SetNext(SIGNALS));
  232. }
  233.  
  234. /*-----------------------*/
  235.  
  236. SetCurrentPinNumber()
  237. {
  238.     int i;
  239.     int len;
  240.     int ch;
  241.  
  242.     currpin = 0;
  243.     CopySymbol(PinNumberString, PinNumberStr);
  244.  
  245.     i = SymbolInCharSet(PinNumberStr);
  246.     if (i == 1) {
  247.         len = SymbolLength(PinNumberString);
  248.  
  249.         i = 0;
  250.         do {
  251.             ch = GetSymbolChar(i, PinNumberStr);
  252.             currpin = (currpin * 10) + (ch - 48);
  253.  
  254.             i = i + 1;
  255.         } while (i < len);
  256.     }
  257. }
  258.  
  259. /*-----------------------*/
  260.  
  261. WriteNetListEnd()
  262. {
  263.     int i;
  264.     int first;
  265.     int ch;
  266.     int len;
  267.     int temp;
  268.  
  269.     /* write the input and bidirectional signals */
  270.     WriteINBISignals();
  271.  
  272.     WriteCrLf(1);
  273.     WriteString(1, "|           -> ");
  274.     WriteCrLf(1);
  275.  
  276.     /* write the output and bidirectional signals */
  277.     WriteOUTBISignals();
  278.     WriteCrLf(1);
  279.  
  280.     WriteString(1, "|  {");
  281.     WriteCrLf(1);
  282.  
  283.     SetFirst(ALL);
  284.     do {
  285.         WriteString(1, "|   ");
  286.         CopySymbol(PartName, Str);
  287.         temp = 0;
  288.         ch = GetSymbolChar(temp, Str);
  289.         /* if 'ch' is a number, then output an underscore before the PartName */
  290.         if (ch >= 48)
  291.         {
  292.             if (ch <= 57)
  293.             {
  294.                 WriteString(1, "_");
  295.             }
  296.         }
  297.         WriteSymbol(1, PartName);
  298.         WriteString(1, " (");
  299.  
  300.         len = 0;
  301.         prevpin = 0;
  302.         first = 1;
  303.         SetFirst(NODES);
  304.         do {
  305.             /* write out any pins between the previous one and the current one */
  306.             SetCurrentPinNumber();
  307.  
  308.             prevpin = prevpin + 1;
  309.             if (currpin > prevpin) {
  310.                 if (currpin != 0) {
  311.                     while (currpin > prevpin) {
  312.                         if (first != 1) { WriteString(1, ","); }
  313.                         WriteString(1, "-");
  314.  
  315.                         first = 0;
  316.                         prevpin = prevpin + 1;
  317.                     }
  318.                 }
  319.             }
  320.             prevpin = currpin;
  321.  
  322.             if (len > 55)
  323.             {
  324.                 len = 0;
  325.                 first = 1;
  326.  
  327.                 WriteString(1, ",");
  328.                 WriteCrLf(1);
  329.                 WriteString(1, "|          ");
  330.             }
  331.  
  332.             if (first != 1) { WriteString(1, ","); }
  333.  
  334.             type = GetStandardSymbol(TypeCode);
  335.             if (type == 'L')
  336.             {
  337.                 if (sw_L == 0)
  338.                 {
  339.                     SetNumberWidth(1);
  340.                     MakeLocalSignal("_");
  341.                     SetNumberWidth(5);
  342.                     WriteSymbol(1, LocalSignal);
  343.                 }
  344.                 else
  345.                 {
  346.                     WriteSymbol(1, SignalNameString);
  347.                 }
  348.             }
  349.             if (type == 'P')
  350.             {
  351.                 WriteSymbol(1, SignalNameString);
  352.  
  353.                 temp = SymbolLength(SignalNameString);
  354.                 len = len + temp + 1;
  355.             }
  356.             if (type == 'S')
  357.             {
  358.                 WriteSymbol(1, SignalNameString);
  359.  
  360.                 temp = SymbolLength(SignalNameString);
  361.                 len = len + temp + 1;
  362.             }
  363.             if (type == 'N')
  364.             {
  365.                 WriteString(1, "N");
  366.                 WriteSymbol(1, NetNumber);
  367.  
  368.                 len = len + 7;
  369.             }
  370.             if (type == 'U')
  371.             {
  372.                 WriteString(1, "-");
  373.  
  374.                 len = len + 2;
  375.             }
  376.  
  377.             first = 0;
  378.         } while (SetNext(NODES));
  379.  
  380.         /* write the reference */
  381.         WriteString(1, ")  | ");
  382.         WriteSymbol(1, ReferenceString);
  383.         WriteCrLf(1);
  384.     } while (SetNext(ALL));
  385.  
  386.     WriteString(1, "|  }");
  387.     WriteCrLf(1);
  388.  
  389.     WriteString(0, "Done");
  390.     WriteCrLf(0);
  391. }
  392.  
  393.  
  394.