home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 13 / 13.iso / p / p078 / 3.img / NETFORMS.PLB / FUTURE.CF < prev    next >
Encoding:
Text File  |  1991-10-14  |  14.9 KB  |  586 lines
  1. /*
  2.     /N Create a netlist (instead of a pinlist)
  3.     /P Output pin numbers (instead of pin names)
  4.     /M Assign SIG* attributes to module ports
  5.     /K Create CON* symbols for module ports
  6.     /V Assign FutureNet power attributes to power objects
  7.     /L Do not append sheet number to label names
  8. */
  9.  
  10. /*  VERSION="1.10   14-OCT-91"
  11.  *      - Removed checking of legal characters and node name length
  12.  *        (to make compatible with SDT/III)
  13.  *      - Added Version message
  14.  *
  15.  *  Capacities:
  16.  *      - Part Names are limited to 16 characters
  17.  *      - Module Names are not checked for length
  18.  *      - Reference Strings are limited to 6 characters
  19.  *      - Node Names are not checked for length
  20.  *      - Node Numbers are limited to 6 digits (plus the leading '***')
  21.  *      - Pin Numbers are not checked for length
  22.  *
  23.  *  Characters:
  24.  *      - Legal characters are not checked
  25.  */
  26.  
  27. int sw_K;
  28. int sw_L;
  29. int sw_M;
  30. int sw_N;
  31. int sw_P;
  32. int sw_V;
  33.  
  34. int type;
  35. int len;
  36. int sym_cnt;
  37.  
  38. /*-----------------------*/
  39.  
  40. Initialize()
  41. {
  42.     WriteString(0, "Creating Netlist...");
  43.     WriteCrLf(0);
  44.  
  45.     /* OrCAD pin attributes to FutureNet attributes */
  46.     SetPinMap(0, "23");
  47.     SetPinMap(1, "22");
  48.     SetPinMap(2, "21");
  49.     SetPinMap(3, "20");
  50.     SetPinMap(4, "23");
  51.     SetPinMap(5, "20");
  52.     SetPinMap(6, "27");
  53.     SetPinMap(7, "23");
  54.  
  55.     sw_K = SwitchIsSet("K");
  56.     sw_M = SwitchIsSet("M");
  57.     sw_N = SwitchIsSet("N");
  58.     sw_P = SwitchIsSet("P");
  59.     sw_V = SwitchIsSet("V");
  60.     sw_L = SwitchIsSet("L");
  61.  
  62.     if (sw_N == 1)
  63.     {
  64.         WriteString(1, "NETLIST,2");
  65.         WriteCrLf(1);
  66.         WriteString(1, "(DRAWING,ORCAD.NET,1-1");
  67.         WriteCrLf(1);
  68.         WriteString(1, "DATA,50,");
  69.         WriteSymbol(1, TitleString);
  70.         WriteCrLf(1);
  71.         WriteString(1, "DATA,51,");
  72.         WriteSymbol(1, DocumentNumber);
  73.         WriteCrLf(1);
  74.         WriteString(1, "DATA,52,");
  75.         WriteSymbol(1, Revision);
  76.         WriteCrLf(1);
  77.         WriteString(1, "DATA,54,");
  78.         WriteSymbol(1, DateString);
  79.         WriteCrLf(1);
  80.         WriteString(1, ")");
  81.     }
  82.     else
  83.     {
  84.         WriteString(1, "PINLIST,2");
  85.         WriteCrLf(1);
  86.         WriteString(1, "(DRAWING,ORCAD.PIN,1-1");
  87.     }
  88.     WriteCrLf(1);
  89.  
  90.     AddSymbol("Error");
  91.     SetSymbol(Error, "E");
  92.  
  93.     AddSymbol("PartNameStr");
  94.     AddSymbol("PinNameStr");
  95.     AddSymbol("ReferenceStr");
  96.     AddSymbol("SignalNameStr");
  97.     AddSymbol("Str");
  98.  
  99.     SetNumberWidth(6);
  100. }
  101.  
  102. /*-----------------------*/
  103.  
  104. WriteHeader()
  105. {
  106.     /* needed for Netlists and Pinlists */
  107.     CreatePartDataBase();
  108.  
  109.     /* review the Part Names and Reference strings for errors */
  110.     while (LoadInstance())
  111.     {
  112.         len = SymbolLength(PartName);
  113.         if (len > 16)
  114.         {
  115.             CopySymbol(PartName, PartNameStr);
  116.             PadSpaces(PartNameStr, 16);
  117.  
  118.             WriteString(0, "ERROR: Name is too long '");
  119.             WriteSymbol(0, PartName);
  120.             WriteString(0, "', truncated to ");
  121.             WriteSymbol(0, PartNameStr);
  122.             WriteCrLf(0);
  123.  
  124.             SetSymbol(ExitType, "E");
  125.         }
  126.  
  127.         len = SymbolLength(ReferenceString);
  128.         if (len > 6)
  129.         {
  130.             CopySymbol(ReferenceString, ReferenceStr);
  131.             PadSpaces(ReferenceStr, 6);
  132.  
  133.             WriteString(0, "ERROR: Reference is too long '");
  134.             WriteSymbol(0, ReferenceString);
  135.             WriteString(0, "', truncated to ");
  136.             WriteSymbol(0, ReferenceStr);
  137.             WriteCrLf(0);
  138.  
  139.             SetSymbol(ExitType, "E");
  140.         }
  141.     }
  142. }
  143.  
  144. /*-----------------------*/
  145.  
  146. ValidateNodeInfo()
  147. {
  148.     /* globals type, legal, and len are set */
  149.     type = GetStandardSymbol(TypeCode);
  150.  
  151.     CopySymbol(SignalNameString, SignalNameStr);
  152.  
  153.     if (type == 'L')
  154.     {
  155.         if (sw_L == 0)
  156.         {
  157.             SetNumberWidth(1);
  158.             MakeLocalSignal("_");
  159.             SetNumberWidth(6);
  160.             CopySymbol(LocalSignal, SignalNameStr);
  161.         }
  162.     }
  163. }
  164.  
  165. /*-----------------------*/
  166.  
  167. WriteNodeInfo()
  168. {
  169.     if (type == 'L')
  170.     {
  171.         WriteSymbol(3, SignalNameStr);
  172.     }
  173.     if (type == 'P')
  174.     {
  175.         WriteSymbol(3, SignalNameStr);
  176.     }
  177.     if (type == 'S')
  178.     {
  179.         WriteSymbol(3, SignalNameStr);
  180.     }
  181.     if (type == 'N')
  182.     {
  183.         WriteString(3, "***");
  184.         WriteSymbol(3, NetNumber);
  185.     }
  186.     if (type == 'U')
  187.     {
  188.         WriteString(3, "***");
  189.         WriteSymbol(3, NetNumber);
  190.     }
  191. }
  192.  
  193. /*-----------------------*/
  194.  
  195. SwitchM()
  196. {
  197.     int i;
  198.  
  199.     if (sw_M == 1)
  200.     {
  201.         if (type == 'P')
  202.         {
  203.             i = GetStandardSymbol(SignalType);
  204.             if (i == 0) { WriteString(3, "5"); }
  205.             if (i == 1) { WriteString(3, "11"); }
  206.             if (i == 2) { WriteString(3, "10"); }
  207.             if (i == 3) { WriteString(3, "12"); }
  208.         }
  209.         else
  210.         {
  211.             WriteString(3, "5");
  212.         }
  213.     }
  214.     else
  215.     {
  216.         WriteString(3, "5");
  217.     }
  218. }
  219.  
  220. /*-----------------------*/
  221.  
  222. HandleNodeName()
  223. {
  224.     int i;
  225.  
  226.     /* check the node name */
  227.     ValidateNodeInfo();
  228.  
  229.     if (sw_N == 1)
  230.     {
  231.  
  232.         WriteString(3, "(SIG,,");
  233.         WriteNodeInfo();
  234.  
  235.         WriteString(3, ",1-1,");
  236.         SwitchM();
  237.         WriteString(3, ",");
  238.         WriteNodeInfo();
  239.  
  240.         WriteCrLf(3);
  241.     }
  242.     else
  243.     {
  244.         /* write out any net that originally had a label.  Illegal  */
  245.         /* characters or length may alter its type.                 */
  246.         if (type == 'L')
  247.         {
  248.             WriteString(3, "SIG,");
  249.             WriteNodeInfo();
  250.             WriteString(3, ",1-1,5,");
  251.             WriteNodeInfo();
  252.             WriteCrLf(3);
  253.         }
  254.         if (type == 'P')
  255.         {
  256.             WriteString(3, "SIG,");
  257.             WriteNodeInfo();
  258.             WriteString(3, ",1-1,");
  259.             SwitchM();
  260.             WriteString(3, ",");
  261.             WriteNodeInfo();
  262.             WriteCrLf(3);
  263.         }
  264.         if (type == 'S')
  265.         {
  266.             WriteString(3, "SIG,");
  267.             WriteNodeInfo();
  268.             WriteString(3, ",1-1,5,");
  269.             WriteNodeInfo();
  270.             WriteCrLf(3);
  271.         }
  272.     }
  273.  
  274.     /* needed for Netlists and Pinlists */
  275.     AddSignalName();
  276. }
  277.  
  278. /*-----------------------*/
  279.  
  280. WriteNet()
  281. {
  282.     int i;
  283.  
  284.     RecordNode();
  285.  
  286.     if (sw_N == 1)
  287.     {
  288.         WriteString(3, "PIN,1-1,");
  289.  
  290.         /* sets PartIndex to be the array index of this Reference */
  291.         CopySymbol(ReferenceString, ReferenceStr);
  292.         SetIndexByRef(ReferenceStr);
  293.         SetNumberWidth(1);
  294.         WriteSymbol(3, PartIndex);
  295.         SetNumberWidth(6);
  296.         WriteString(3, ",");
  297.  
  298.         WriteSymbol(3, ReferenceStr);
  299.         WriteString(3, ",");
  300.  
  301.         i = GetStandardSymbol(PinType);
  302.         WriteMap(3, i);
  303.         WriteString(3, ",");
  304.  
  305.         if (sw_P == 1)
  306.             { WriteSymbol(3, PinNumberString); }
  307.         else
  308.             { WriteSymbol(3, PinNameString); }
  309.  
  310.         WriteCrLf(3);
  311.     }
  312. }
  313.  
  314. /*-----------------------*/
  315.  
  316. WriteNetEnding()
  317. {
  318.     if (sw_N == 1)
  319.     {
  320.         WriteString(3, ")");
  321.         WriteCrLf(3);
  322.     }
  323. }
  324.  
  325. /*-----------------------*/
  326.  
  327. ProcessFieldStrings()
  328. {
  329. }
  330.  
  331. /*-----------------------*/
  332.  
  333. SwitchK()
  334. {
  335.     int i;
  336.  
  337.     if (sw_K == 1)
  338.     {
  339.         SetFirst(SIGNALS);
  340.         do {
  341.             i = GetStandardSymbol(SignalType);
  342.             if (i != 0)
  343.             {
  344.                 ValidateNodeInfo();
  345.  
  346.                 if (type == 'P')
  347.                 {
  348.                     sym_cnt = sym_cnt + 1;
  349.                     WriteString(1, "(SYM,");
  350.                     SetNumberWidth(1);
  351.                     WriteInteger(1, sym_cnt); 
  352.                     SetNumberWidth(6);
  353.                     WriteCrLf(1);
  354.  
  355.                     WriteString(1, "DATA,2,");
  356.                     if (i == 1) { WriteString(1, "CONO"); }
  357.                     if (i == 2) { WriteString(1, "CONI"); }
  358.                     if (i == 3) { WriteString(1, "CONB"); }
  359.                     WriteCrLf(1);
  360.             
  361.                     WriteString(1, "PIN,,");
  362.                     WriteSymbol(1, SignalNameString);
  363.                     WriteString(1, ",1-1,");
  364.  
  365.                     /* for writing the correct module port attributes */
  366.                     if (sw_M == 1)
  367.                     {
  368.                         if (i == 0) { WriteString(1, "5"); }
  369.                         if (i == 1) { WriteString(1, "11"); }
  370.                         if (i == 2) { WriteString(1, "10"); }
  371.                         if (i == 3) { WriteString(1, "12"); }
  372.                     }
  373.                     else
  374.                     {
  375.                         WriteString(1, "5");
  376.                     }
  377.             
  378.                     if (i == 1) { WriteString(1, ",25"); }
  379.                     if (i == 2) { WriteString(1, ",24"); }
  380.                     if (i == 3) { WriteString(1, ",26"); }
  381.  
  382.                     if (i == 1) { WriteString(1, ",OUT"); }
  383.                     if (i == 2) { WriteString(1, ",IN"); }
  384.                     if (i == 3) { WriteString(1, ",IO"); }
  385.                     WriteCrLf(1);
  386.                     WriteString(1, ")");
  387.                     WriteCrLf(1);
  388.                 }
  389.             }
  390.         } while (SetNext(SIGNALS));
  391.     }
  392. }
  393.  
  394. /*-----------------------*/
  395.  
  396. WriteNetListEnd()
  397. {
  398.     int i;
  399.     int j;
  400.     int ok;
  401.     int net;
  402.  
  403.     net = 0;
  404.  
  405.     if (sw_N == 0)
  406.     {
  407.         WriteString(3, ")");
  408.         WriteCrLf(3);
  409.     }
  410.  
  411.     sym_cnt = 0;
  412.     SetFirst(ALL);
  413.     do {
  414.         CopySymbol(ReferenceString, Str);
  415.         LoadFieldString(Str);
  416.  
  417.         SetNumberWidth(1);
  418.         if (sw_N == 1)
  419.         {
  420.             WriteString(1, "(SYM,1-1,");
  421.             WriteSymbol(1, PartIndex);
  422.         }
  423.         else
  424.         {
  425.             WriteString(1, "(SYM,");
  426.             WriteSymbol(1, PartIndex);
  427.         }
  428.         SetNumberWidth(6);
  429.         WriteCrLf(1);
  430.  
  431.         /* for numbering CON* symbols if sw_K is set */
  432.         i = GetStandardSymbol(PartIndex);
  433.         if (i > sym_cnt) { sym_cnt = i; }
  434.  
  435.         WriteString(1, "DATA,2,");
  436.         CopySymbol(ReferenceString, ReferenceStr);
  437.         len = SymbolLength(ReferenceString);
  438.         if (len > 6)
  439.         {
  440.             PadSpaces(ReferenceStr, 6);
  441.         }
  442.         WriteSymbol(1, ReferenceStr);
  443.         WriteCrLf(1);
  444.  
  445.         WriteString(1, "DATA,3,");
  446.         CopySymbol(PartName, PartNameStr);
  447.         len = SymbolLength(PartNameStr);
  448.         if (len > 16)
  449.         {
  450.             PadSpaces(PartNameStr, 16);
  451.         }
  452.         WriteSymbol(1, PartNameStr);
  453.         WriteCrLf(1);
  454.  
  455.         WriteString(1, "DATA,4,");
  456.         len = SymbolLength(ModuleName);
  457.         if (len > 0)
  458.             { WriteSymbol(1, ModuleName); }
  459.         else
  460.             { WriteSymbol(1, PartName); }
  461.         WriteCrLf(1);
  462.  
  463.         do {
  464.             if (sw_N == 1)
  465.             {
  466.                 WriteString(1, "DATA,");
  467.  
  468.                 i = GetStandardSymbol(PinType);
  469.                 WriteMap(1, i);
  470.                 WriteString(1, ",");
  471.             }
  472.             else
  473.             {
  474.                 WriteString(1, "PIN,,");
  475.  
  476.                 ValidateNodeInfo();
  477.                 if (type == 'L')
  478.                 {
  479.                     WriteSymbol(1, SignalNameStr);
  480.                 }
  481.                 if (type == 'P')
  482.                 {
  483.                     WriteSymbol(1, SignalNameStr);
  484.                 }
  485.                 if (type == 'S')
  486.                 {
  487.                     WriteSymbol(1, SignalNameStr);
  488.                 }
  489.                 if (type == 'N')
  490.                 {
  491.                     WriteString(1, "***");
  492.                     WriteSymbol(1, NetNumber);
  493.                 }
  494.                 if (type == 'U')
  495.                 {
  496.                     WriteString(1, "UN");
  497.                     net = net + 1;
  498.                     WriteInteger(1, net);
  499.                 }
  500.  
  501.                 WriteString(1, ",1-1,");
  502.                 if (sw_M == 1)
  503.                 {
  504.                     if (type == 'L') { WriteString(1, "5"); }
  505.                     if (type == 'P')
  506.                     {
  507.                         i = GetStandardSymbol(SignalType);
  508.                         if (i == 0) { WriteString(1, "5"); }
  509.                         if (i == 1) { WriteString(1, "11"); }
  510.                         if (i == 2) { WriteString(1, "10"); }
  511.                         if (i == 3) { WriteString(1, "12"); }
  512.                     }
  513.                     if (type == 'S') { WriteString(1, "5"); }
  514.                     if (type == 'N') { WriteString(1, "5"); }
  515.                     if (type == 'U') { WriteString(1, "5"); }
  516.                 }
  517.                 else
  518.                 {
  519.                     WriteString(1, "5");
  520.                 }
  521.                 WriteString(1, ",");
  522.  
  523.                 i = GetStandardSymbol(PinType);
  524.                 if (sw_V == 1)
  525.                 {
  526.                     if (type == 'S')
  527.                     {
  528.                         j = 0;
  529.                         ok = 0;
  530.  
  531.                         SetSymbol(PinNameStr, "GND");
  532.                         j = CompareSymbol(PinNameString, PinNameStr);
  533.                         if (j == 0) { WriteString(1, "100");    ok = 1; }
  534.                         SetSymbol(PinNameStr, "+5V");
  535.                         j = CompareSymbol(PinNameString, PinNameStr);
  536.                         if (j == 0) { WriteString(1, "101");    ok = 1; }
  537.                         SetSymbol(PinNameStr, "+12V");
  538.                         j = CompareSymbol(PinNameString, PinNameStr);
  539.                         if (j == 0) { WriteString(1, "105");    ok = 1; }
  540.                         SetSymbol(PinNameStr, "-12V");
  541.                         j = CompareSymbol(PinNameString, PinNameStr);
  542.                         if (j == 0) { WriteString(1, "106");    ok = 1; }
  543.                         SetSymbol(PinNameStr, "VEE");
  544.                         j = CompareSymbol(PinNameString, PinNameStr);
  545.                         if (j == 0) { WriteString(1, "107");    ok = 1; }
  546.  
  547.                         if (ok == 0) { WriteMap(1, i); }
  548.                     }
  549.                     else
  550.                     {
  551.                         WriteMap(1, i);
  552.                     }
  553.                 }
  554.                 else
  555.                 {
  556.                     WriteMap(1, i);
  557.                 }
  558.  
  559.                 WriteString(1, ",");
  560.             }
  561.  
  562.             if (sw_P == 1)
  563.                 { WriteSymbol(1, PinNumberString); }
  564.             else
  565.                 { WriteSymbol(1, PinNameString); }
  566.  
  567.             WriteCrLf(1);
  568.         } while (SetNext(NODES));
  569.  
  570.         WriteString(1, ")");
  571.         WriteCrLf(1);
  572.  
  573.     } while (SetNext(ALL));
  574.  
  575.     /* for creating the CON* objects -- if necessary */
  576.     SwitchK();
  577.  
  578.     /* add the net oriented info to the end of the part  */
  579.     /* oriented info for Netlist formats.                */
  580.     ConcatFile(1, 3);
  581.  
  582.     WriteString(0, "Done");
  583.     WriteCrLf(0);
  584. }
  585.  
  586.