projects / tas-yagle.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Initial version of donated sources by Avertec, 3.4p5.
[tas-yagle.git] / distrib / sources / cns / cnsfigdrv.c
1 /*
2 * This file is part of the Alliance CAD System
3 * Copyright (C) Laboratoire LIP6 - D\8epartement ASIM
4 * Universite Pierre et Marie Curie
5 *
6 * Home page : http://www-asim.lip6.fr/alliance/
7 * E-mail support : mailto:alliance-support@asim.lip6.fr
8 *
9 * This library is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU Library General Public License as published
11 * by the Free Software Foundation; either version 2 of the License, or (at
12 * your option) any later version.
13 *
14 * Alliance VLSI CAD System is distributed in the hope that it will be
15 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
17 * Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with the GNU C Library; see the file COPYING. If not, write to the Free
21 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 /* 10/23/97 Cone Netlist Structure functions: savecnsfig.c */
25
26 #include"cnsall.h"
27
28 /*============================================================================*
29 | function savecnsfig(); |
30 | Cone Netlist Structure driver |
31 *============================================================================*/
32 void
33 savecnsfig(ptcnsfig, ptlofig)
34 cnsfig_list *ptcnsfig;
35 lofig_list *ptlofig;
36 {
37 if (V_BOOL_TAB[__CNS_DRIVE_VERBOSE].VALUE) savecnvfig(ptcnsfig);
38 if (V_BOOL_TAB[__CNS_DRIVE_NORMAL].VALUE) savecnslofig(ptcnsfig, ptlofig, 1);
39 }
40
41 /*============================================================================*
42 | function savecnslofig(); |
43 | Cone Netlist Structure with embedded lofig driver |
44 *============================================================================*/
45 void
46 savecnslofig(ptcnsfig, ptlofig, complete)
47 cnsfig_list *ptcnsfig;
48 lofig_list *ptlofig;
49 int complete;
50 {
51 FILE *ptfile;
52 time_t counter;
53 locon_list *ptlocon;
54 short error = 0;
55 lotrs_list *ptlotrs;
56 loins_list *ptloins;
57 losig_list *ptlosig;
58 lorcnet_list *ptrcnet;
59 lowire_list *ptwire;
60 loctc_list *ptctc;
61 ptype_list *ptptype;
62 cone_list *ptcone;
63 char lotrs_type[8];
64 char losig_type[8];
65 cell_list *ptcell;
66 char cell_type[16];
67 long counter1;
68 chain_list *ptchain;
69 num_list *ptnum;
70 cone_list *ptcone0;
71 char cone_type[8];
72 char cone_tectype[16];
73 edge_list *ptedge;
74 cone_list *ptcone1;
75 branch_list *ptbranch;
76 chain_list *ptchain0;
77 ptype_list *ptptype0;
78 chain_list *ptchain1;
79 ptype_list *ptptype1;
80 char *ptname;
81 optparam_list *ptopt;
82 int first;
83 int cachemode;
84
85 if (CNS_TRACE_MODE >= CNS_TRACE)
86 (void) printf("TRA_cns savecnsfig in\n");
87
88 if (ptcnsfig == NULL || ptlofig == NULL) {
89 (void) fflush(stdout);
90 (void) fprintf(stderr, "*** cns error ***");
91 (void) fprintf(stderr, " savecnsfig() impossible for %s.cns : both logical and CNS figures are required\n", ptcnsfig->NAME);
92 if (CNS_TRACE_MODE >= CNS_TRACE)
93 (void) printf("TRA_cns savecnsfig out\n");
94 EXIT(-1);
95 }
96
97 /* ---------------------------------------------------------------------------
98 open file
99 --------------------------------------------------------------------------- */
100
101 if ((ptfile = mbkfopen(ptcnsfig->NAME, "cns", WRITE_TEXT)) == NULL) {
102 (void) fflush(stdout);
103 (void) fprintf(stderr, "*** cns error ***");
104 (void) fprintf(stderr, " savecnsfig() impossible: can't open file %s.cns\n", ptcnsfig->NAME);
105 if (CNS_TRACE_MODE >= CNS_TRACE)
106 (void) printf("TRA_cns savecnsfig out\n");
107 EXIT(-1);
108 }
109
110 /* ---------------------------------------------------------------------------
111 header
112 --------------------------------------------------------------------------- */
113 time(&counter);
114 fprintf(ptfile, "(CNS V%s %s %s %s %s %s", CNS_VERSION, CNS_TECHNO, IN_LO, ptcnsfig->NAME, getenv("USER"), ctime(&counter));
115
116 /* ---------------------------------------------------------------------------
117 capacity scale
118 --------------------------------------------------------------------------- */
119 fprintf(ptfile, "\n(SCALE\n(X %ld))\n", SCALE_X);
120
121 /* ---------------------------------------------------------------------------
122 signal indexing
123 --------------------------------------------------------------------------- */
124 if (ptlofig != NULL) {
125 counter = 0;
126 for (ptlosig = ptlofig->LOSIG; ptlosig; ptlosig = ptlosig->NEXT) {
127 counter++;
128 if ((ptptype = getptype(ptlosig->USER, (long) CNS_INDEX)) != NULL) {
129 ptptype->DATA = (void *) counter;
130 }
131 else {
132 ptlosig->USER = addptype(ptlosig->USER, (long) CNS_INDEX, (void *) counter);
133 }
134 }
135 }
136 /* ---------------------------------------------------------------------------
137 Cone Netlist Structure external connector list
138 --------------------------------------------------------------------------- */
139 counter = 0;
140 fprintf(ptfile, "\n(CONNECTORS");
141 for (ptlocon = ptcnsfig->LOCON; ptlocon != NULL; ptlocon = ptlocon->NEXT) {
142 counter++;
143 if ((ptptype = getptype(ptlocon->USER, (long) CNS_INDEX)) != NULL) {
144 ptptype->DATA = (void *) counter;
145 }
146 else {
147 ptlocon->USER = addptype(ptlocon->USER, (long) CNS_INDEX, (void *) counter);
148 }
149 if (strchr(ptlocon->NAME, ' ') != NULL) {
150 fprintf(ptfile, "\n(%ld \"%s\"", counter, ptlocon->NAME);
151 }
152 else fprintf(ptfile, "\n(%ld %s", counter, ptlocon->NAME);
153 if (ptlocon->DIRECTION == CNS_I)
154 fprintf(ptfile, " I");
155 else if (ptlocon->DIRECTION == CNS_O)
156 fprintf(ptfile, " O");
157 else if (ptlocon->DIRECTION == CNS_B)
158 fprintf(ptfile, " B");
159 else if (ptlocon->DIRECTION == CNS_Z)
160 fprintf(ptfile, " Z");
161 else if (ptlocon->DIRECTION == CNS_T)
162 fprintf(ptfile, " T");
163 else if (ptlocon->DIRECTION == CNS_X)
164 fprintf(ptfile, " X");
165 else if (ptlocon->DIRECTION == CNS_VDDC)
166 fprintf(ptfile, " Vdd");
167 else if (ptlocon->DIRECTION == CNS_GNDC)
168 fprintf(ptfile, " Gnd");
169 else if (ptlocon->DIRECTION == CNS_VSSC)
170 fprintf(ptfile, " Vss");
171 else {
172 fprintf(ptfile, " ?");
173 error = 1;
174 }
175 if (ptlocon->TYPE == 'I')
176 fprintf(ptfile, " I");
177 else if (ptlocon->TYPE == 'E')
178 fprintf(ptfile, " E");
179 else if (ptlocon->TYPE == 'X')
180 fprintf(ptfile, " X");
181 else {
182 fprintf(ptfile, " ?");
183 error = 1;
184 }
185 if (ptlofig != NULL && (ptptype = getptype(ptlocon->SIG->USER, (long) CNS_INDEX)) != NULL) {
186 fprintf(ptfile, " %ld", (long) ptptype->DATA);
187 if (ptlocon->PNODE != NULL && complete) {
188 fprintf(ptfile, " (#");
189 for (ptnum = ptlocon->PNODE; ptnum; ptnum = ptnum->NEXT) {
190 fprintf(ptfile, " %ld", ptnum->DATA);
191 }
192 fprintf(ptfile, ")");
193 }
194 }
195 ptptype = getptype(ptlocon->USER, CNS_TYPELOCON);
196 if (ptptype != NULL) {
197 if (((long)ptptype->DATA & CNS_ONE) == CNS_ONE) fprintf(ptfile, " - 1");
198 else if (((long)ptptype->DATA & CNS_ZERO) == CNS_ZERO) fprintf(ptfile, " - 0");
199 }
200 fprintf(ptfile, ")");
201 }
202 fprintf(ptfile, ")\n");
203
204 /* ---------------------------------------------------------------------------
205 Cone Netlist Structure internal connector list
206 --------------------------------------------------------------------------- */
207 if (ptcnsfig->INTCON != NULL) {
208 fprintf(ptfile, "\n(INTERNAL");
209 for (ptlocon = ptcnsfig->INTCON; ptlocon != NULL; ptlocon = ptlocon->NEXT) {
210 counter++;
211 if ((ptptype = getptype(ptlocon->USER, (long) CNS_INDEX)) != NULL) {
212 ptptype->DATA = (void *) counter;
213 }
214 else {
215 ptlocon->USER = addptype(ptlocon->USER, (long) CNS_INDEX, (void *) counter);
216 }
217 if (strchr(ptlocon->NAME, ' ') != NULL) {
218 fprintf(ptfile, "\n(%ld \"%s\"", counter, ptlocon->NAME);
219 }
220 else fprintf(ptfile, "\n(%ld %s", counter, ptlocon->NAME);
221 if (ptlocon->DIRECTION == CNS_I)
222 fprintf(ptfile, " I");
223 else if (ptlocon->DIRECTION == CNS_O)
224 fprintf(ptfile, " O");
225 else if (ptlocon->DIRECTION == CNS_B)
226 fprintf(ptfile, " B");
227 else if (ptlocon->DIRECTION == CNS_Z)
228 fprintf(ptfile, " Z");
229 else if (ptlocon->DIRECTION == CNS_T)
230 fprintf(ptfile, " T");
231 else if (ptlocon->DIRECTION == CNS_X)
232 fprintf(ptfile, " X");
233 else if (ptlocon->DIRECTION == CNS_VDDC)
234 fprintf(ptfile, " Vdd");
235 else if (ptlocon->DIRECTION == CNS_GNDC)
236 fprintf(ptfile, " Gnd");
237 else if (ptlocon->DIRECTION == CNS_VSSC)
238 fprintf(ptfile, " Vss");
239 else {
240 fprintf(ptfile, " ?");
241 error = 1;
242 }
243 if (ptlofig != NULL && (ptptype = getptype(ptlocon->SIG->USER, (long) CNS_INDEX)) != NULL) {
244 fprintf(ptfile, " %ld", (long) ptptype->DATA);
245 if (ptlocon->PNODE != NULL) {
246 fprintf(ptfile, " (#");
247 for (ptnum = ptlocon->PNODE; ptnum; ptnum = ptnum->NEXT) {
248 fprintf(ptfile, " %ld", ptnum->DATA);
249 }
250 fprintf(ptfile, ")");
251 }
252 }
253 fprintf(ptfile, ")");
254 }
255 fprintf(ptfile, ")\n");
256 }
257
258 /* ---------------------------------------------------------------------------
259 Lofig Structure signal list
260 --------------------------------------------------------------------------- */
261 if (ptlofig!= NULL) {
262 cachemode=rcn_hascache(ptlofig);
263 fprintf(ptfile, "\n(SIGNALS");
264 for (ptlosig = ptlofig->LOSIG; ptlosig; ptlosig = ptlosig->NEXT) {
265 ptptype = getptype(ptlosig->USER, CNS_INDEX);
266 counter = (long) ptptype->DATA;
267 if (complete) fprintf(ptfile, "\n");
268 fprintf(ptfile, "\n(%ld (", counter);
269 if ((ptchain = ptlosig->NAMECHAIN) != NULL) {
270 ptname = (char *)ptchain->DATA;
271 if (strchr(ptname, ' ') != NULL) {
272 fprintf(ptfile, "\"%s\"", ptname);
273 }
274 else fprintf(ptfile, "%s", ptname);
275 while ((ptchain = ptchain->NEXT) != NULL) {
276 ptname = (char *)ptchain->DATA;
277 if (strchr(ptname, ' ') != NULL) {
278 fprintf(ptfile, " \"%s\"", ptname);
279 }
280 else fprintf(ptfile, " %s", ptname);
281 }
282 }
283 else
284 fprintf(ptfile, "cns_sig%ld", counter);
285 strcpy(losig_type, "");
286 switch (ptlosig->TYPE) {
287 case CNS_SIGINT:
288 strcat(losig_type, "I");
289 break;
290 case CNS_SIGEXT:
291 strcat(losig_type, "E");
292 break;
293 case CNS_SIGVDD:
294 strcat(losig_type, "D");
295 break;
296 case CNS_SIGVSS:
297 strcat(losig_type, "S");
298 break;
299 case CNS_SIGTRANSP:
300 strcat(losig_type, "T");
301 break;
302 default:
303 strcat(losig_type, "?");
304 }
305 fprintf(ptfile, ") %s", losig_type);
306 if ((ptptype = getptype(ptlosig->USER, LOSIGALIM)) != NULL) {
307 fprintf(ptfile, " (%ld)", (long)ptptype->DATA);
308 }
309 if ((ptrcnet = ptlosig->PRCN) != NULL && complete) {
310 if (!(cachemode && (mbk_LosigIsVDD(ptlosig) || mbk_LosigIsVSS(ptlosig))))
311 {
312 rcn_lock_signal(ptlofig, ptlosig);
313 fprintf(ptfile, " %3.2f", rcn_getcapa( ptlofig, ptlosig ) * 1000);
314 if (ptrcnet->PWIRE != NULL) {
315 fprintf(ptfile, "\n(WIRES");
316 for (ptwire = ptrcnet->PWIRE; ptwire; ptwire = ptwire->NEXT) {
317 fprintf(ptfile, "\n(X");
318 fprintf(ptfile, " %ld %ld %g %g)", ptwire->NODE1, ptwire->NODE2, ptwire->RESI, ptwire->CAPA * 1000);
319 }
320 fprintf(ptfile, ")");
321 }
322 rcn_unlock_signal(ptlofig, ptlosig);
323 }
324 }
325 else if (ptrcnet != NULL) {
326 fprintf(ptfile, " %3.2f", rcn_getcapa( ptlofig, ptlosig ) * 1000);
327 }
328 else
329 fprintf(ptfile, " 0");
330 fprintf(ptfile, ")");
331 }
332 fprintf(ptfile, ")\n");
333 }
334
335 /* ---------------------------------------------------------------------------
336 Crosstalk Capacitances list
337 --------------------------------------------------------------------------- */
338 if (ptlofig != NULL && complete) {
339 fprintf(ptfile, "\n(CROSSTALKS");
340 for (ptlosig = ptlofig->LOSIG; ptlosig; ptlosig = ptlosig->NEXT) {
341 if (ptlosig->PRCN == NULL) continue;
342 if (cachemode && (mbk_LosigIsVDD(ptlosig) || mbk_LosigIsVSS(ptlosig))) continue;
343 rcn_lock_signal(ptlofig, ptlosig);
344 for (ptchain = ptlosig->PRCN->PCTC; ptchain; ptchain = ptchain->NEXT) {
345 ptctc = (loctc_list *)ptchain->DATA;
346 if (rcn_capacitancetooutput(cachemode, ptlosig, ptctc)) {
347 fprintf(ptfile, "\n(K %g", ptctc->CAPA * 1000);
348 ptptype = getptype(ptctc->SIG1->USER, CNS_INDEX);
349 counter = (long) ptptype->DATA;
350 fprintf(ptfile, " %ld", counter);
351 fprintf(ptfile, " %ld", ptctc->NODE1);
352 ptptype = getptype(ptctc->SIG2->USER, CNS_INDEX);
353 counter = (long) ptptype->DATA;
354 fprintf(ptfile, " %ld", counter);
355 fprintf(ptfile, " %ld)", ptctc->NODE2);
356 }
357 }
358 rcn_unlock_signal(ptlofig, ptlosig);
359 }
360 fprintf(ptfile, ")\n");
361 }
362
363 /* ---------------------------------------------------------------------------
364 Cone Netlist Structure transistor list
365 --------------------------------------------------------------------------- */
366 counter = 0;
367 fprintf(ptfile, "\n(TRANSISTORS");
368 for (ptlotrs = ptcnsfig->LOTRS; ptlotrs != NULL; ptlotrs = ptlotrs->NEXT) {
369 counter++;
370 if ((ptptype = getptype(ptlotrs->USER, (long) CNS_INDEX)) != NULL) {
371 ptptype->DATA = (void *) counter;
372 }
373 else {
374 ptlotrs->USER = addptype(ptlotrs->USER, (long) CNS_INDEX, (void *) counter);
375 }
376 fprintf(ptfile, "\n(%ld", counter);
377 if (ptlotrs->TRNAME != NULL) {
378 if (isdigit((int)*(ptlotrs->TRNAME))) fprintf(ptfile, " cns_%s", ptlotrs->TRNAME);
379 else fprintf(ptfile, " %s", ptlotrs->TRNAME);
380 }
381 else {
382 fprintf(ptfile, " noname");
383 }
384 if ((ptptype = getptype(ptlotrs->USER, (long) CNS_DRIVINGCONE)) != NULL) {
385 fprintf(ptfile, " %ld", ((cone_list *) ptptype->DATA)->INDEX);
386 }
387 else if ((ptptype = getptype(ptlotrs->USER, (long) CNS_LINKTYPE)) != NULL) {
388 if (((long) ptptype->DATA & CNS_ACTIVE) == CNS_ACTIVE) {
389 if ((ptcone = (cone_list *) ptlotrs->GRID) != NULL) {
390 fprintf(ptfile, " %ld", ptcone->INDEX);
391 }
392 else {
393 fprintf(ptfile, " ?");
394 error = 1;
395 }
396 }
397 else if (((long) ptptype->DATA & CNS_PULL) == CNS_PULL)
398 fprintf(ptfile, " puller");
399 else if (((long) ptptype->DATA & (CNS_DIODE_UP & CNS_DIODE_DOWN)) == (CNS_DIODE_UP & CNS_DIODE_DOWN))
400 fprintf(ptfile, " diode");
401 else if (((long) ptptype->DATA & CNS_RESIST) == CNS_RESIST)
402 fprintf(ptfile, " resistance");
403 else if (((long) ptptype->DATA & CNS_CAPA) == CNS_CAPA)
404 fprintf(ptfile, " capacity");
405 else {
406 fprintf(ptfile, " ?");
407 error = 1;
408 }
409 }
410 /*else if ((ptcone = (cone_list *) ptlotrs->GRID) != NULL) {
411 fprintf(ptfile, " %ld", ptcone->INDEX);
412 }*/
413 else {
414 fprintf(ptfile, " 0");
415 }
416 if (ptlotrs->X != LONG_MIN) fprintf(ptfile, " %ld", ptlotrs->X);
417 else fprintf(ptfile, " 0");
418 if (ptlotrs->X != LONG_MIN) fprintf(ptfile, " %ld", ptlotrs->Y);
419 else fprintf(ptfile, " 0");
420 fprintf(ptfile, " %ld %ld", ptlotrs->WIDTH, ptlotrs->LENGTH);
421 fprintf(ptfile, " %ld %ld", ptlotrs->PS, ptlotrs->PD);
422 fprintf(ptfile, " %ld %ld", ptlotrs->XS, ptlotrs->XD);
423 if (ptlofig != NULL) {
424 ptlosig = ptlotrs->DRAIN->SIG;
425 ptptype = getptype(ptlosig->USER, CNS_INDEX);
426 fprintf(ptfile, " %ld", (long) ptptype->DATA);
427 if (ptlotrs->DRAIN->PNODE != NULL && complete) {
428 fprintf(ptfile, " (#");
429 for (ptnum = ptlotrs->DRAIN->PNODE; ptnum; ptnum = ptnum->NEXT) {
430 fprintf(ptfile, " %ld", (long) ptnum->DATA);
431 }
432 fprintf(ptfile, ")");
433 }
434 ptlosig = ptlotrs->GRID->SIG;
435 ptptype = getptype(ptlosig->USER, CNS_INDEX);
436 fprintf(ptfile, " %ld", (long) ptptype->DATA);
437 if (ptlotrs->GRID->PNODE != NULL && complete) {
438 fprintf(ptfile, " (#");
439 for (ptnum = ptlotrs->GRID->PNODE; ptnum; ptnum = ptnum->NEXT) {
440 fprintf(ptfile, " %ld", (long) ptnum->DATA);
441 }
442 fprintf(ptfile, ")");
443 }
444 ptlosig = ptlotrs->SOURCE->SIG;
445 ptptype = getptype(ptlosig->USER, CNS_INDEX);
446 fprintf(ptfile, " %ld", (long) ptptype->DATA);
447 if (ptlotrs->SOURCE->PNODE != NULL && complete) {
448 fprintf(ptfile, " (#");
449 for (ptnum = ptlotrs->SOURCE->PNODE; ptnum; ptnum = ptnum->NEXT) {
450 fprintf(ptfile, " %ld", (long) ptnum->DATA);
451 }
452 fprintf(ptfile, ")");
453 }
454 if (ptlotrs->BULK==NULL) ptlosig=NULL;
455 else ptlosig = ptlotrs->BULK->SIG;
456 if (ptlosig != NULL) {
457 ptptype = getptype(ptlosig->USER, CNS_INDEX);
458 fprintf(ptfile, " %ld", (long) ptptype->DATA);
459 if (ptlotrs->BULK->PNODE != NULL && complete) {
460 fprintf(ptfile, " (#");
461 for (ptnum = ptlotrs->BULK->PNODE; ptnum; ptnum = ptnum->NEXT) {
462 fprintf(ptfile, " %ld", (long) ptnum->DATA);
463 }
464 fprintf(ptfile, ")");
465 }
466 }
467 else fprintf(ptfile, " 0");
468 }
469 strcpy(lotrs_type, "");
470 if (strcmp(CNS_TECHNO, "edmesfet") == 0) {
471 if (MLO_IS_TRANSN(ptlotrs->TYPE))
472 strcat(lotrs_type, "E");
473 else if (MLO_IS_TRANSP(ptlotrs->TYPE))
474 strcat(lotrs_type, "D");
475 }
476 else if (strcmp(CNS_TECHNO, "npmosfet") == 0) {
477 if (MLO_IS_TRANSN(ptlotrs->TYPE))
478 strcat(lotrs_type, "N");
479 else if (MLO_IS_TRANSP(ptlotrs->TYPE))
480 strcat(lotrs_type, "P");
481 }
482 if (strlen(lotrs_type) == 0) {
483 strcat(lotrs_type, "?");
484 error = 1;
485 }
486 if (ptlotrs->MODINDEX == EMPTYHT) fprintf(ptfile, " %s", lotrs_type);
487 else fprintf(ptfile, " %s %s", lotrs_type, getlotrsmodel(ptlotrs));
488 fprintf(ptfile, " (");
489 if ((ptptype = getptype(ptlotrs->USER, OPT_PARAMS)) != NULL) {
490 first = 1;
491 for (ptopt = (optparam_list*)ptptype->DATA; ptopt; ptopt = ptopt->NEXT) {
492 if (isknowntrsparam(ptopt->UNAME.STANDARD)) {
493 if (**(ptopt->UNAME.STANDARD) != '$') {
494 if (first) {
495 first = 0;
496 }
497 else fprintf(ptfile, " ");
498 fprintf(ptfile, "%s=%g", *(ptopt->UNAME.STANDARD), ptopt->UDATA.VALUE);
499 }
500 }
501 }
502 }
503 fprintf(ptfile, ")");
504 fprintf(ptfile, " (");
505 if ((ptptype = getptype(ptlotrs->USER, PARAM_CONTEXT)) != NULL) {
506 char *subcktname;
507 eqt_param *from=(eqt_param *)ptptype->DATA;
508 int i;
509 subcktname=mbk_get_subckt_name(ptlotrs);
510 fprintf(ptfile, " %s", subcktname!=NULL?subcktname:"");
511 for (i = 0; i < from->NUMBER; i++)
512 fprintf(ptfile, " %s=%g", from->EBI[i].NAME, from->EBI[i].VAL);
513 }
514 fprintf(ptfile, ")");
515 fprintf(ptfile, ")");
516 }
517 fprintf(ptfile, ")\n");
518
519 /* ---------------------------------------------------------------------------
520 Cone Netlist Structure instance list
521 --------------------------------------------------------------------------- */
522 counter = 0;
523 fprintf(ptfile, "\n(INSTANCES");
524 for (ptloins = ptcnsfig->LOINS; ptloins != NULL; ptloins = ptloins->NEXT) {
525 counter++;
526 if ((ptptype = getptype(ptloins->USER, (long) CNS_INDEX)) != NULL) {
527 ptptype->DATA = (void *) counter;
528 }
529 else {
530 ptloins->USER = addptype(ptloins->USER, (long) CNS_INDEX, (void *) counter);
531 }
532 fprintf(ptfile, "\n\n(%ld", counter);
533 if (strchr(ptloins->INSNAME, ' ') != NULL) {
534 fprintf(ptfile, " \"%s\" %s", ptloins->INSNAME, ptloins->FIGNAME);
535 }
536 else fprintf(ptfile, " %s %s", ptloins->INSNAME, ptloins->FIGNAME);
537 counter1 = 0;
538 fprintf(ptfile, "\n(CONNECTORS");
539 ptloins->LOCON = (locon_list *)reverse((chain_list *)ptloins->LOCON);
540 for (ptlocon = ptloins->LOCON; ptlocon != NULL; ptlocon = ptlocon->NEXT) {
541 counter1++;
542 if ((ptptype = getptype(ptlocon->USER, (long) CNS_INDEX)) != NULL) {
543 ptptype->DATA = (void *) counter1;
544 }
545 else {
546 ptlocon->USER = addptype(ptlocon->USER, (long) CNS_INDEX, (void *) counter1);
547 }
548 if (strchr(ptlocon->NAME, ' ') != NULL) {
549 fprintf(ptfile, "\n(%ld \"%s\"", counter1, ptlocon->NAME);
550 }
551 else fprintf(ptfile, "\n(%ld %s", counter1, ptlocon->NAME);
552 if (ptlocon->DIRECTION == CNS_I)
553 fprintf(ptfile, " I");
554 else if (ptlocon->DIRECTION == CNS_O)
555 fprintf(ptfile, " O");
556 else if (ptlocon->DIRECTION == CNS_B)
557 fprintf(ptfile, " B");
558 else if (ptlocon->DIRECTION == CNS_Z)
559 fprintf(ptfile, " Z");
560 else if (ptlocon->DIRECTION == CNS_T)
561 fprintf(ptfile, " T");
562 else if (ptlocon->DIRECTION == CNS_X)
563 fprintf(ptfile, " X");
564 else if (ptlocon->DIRECTION == CNS_VDDC)
565 fprintf(ptfile, " Vdd");
566 else if (ptlocon->DIRECTION == CNS_GNDC)
567 fprintf(ptfile, " Gnd");
568 else if (ptlocon->DIRECTION == CNS_VSSC)
569 fprintf(ptfile, " Vss");
570 else {
571 fprintf(ptfile, " ?");
572 error = 1;
573 }
574 if (ptlofig != NULL && (ptptype = getptype(ptlocon->SIG->USER, (long) CNS_INDEX)) != NULL) {
575 fprintf(ptfile, " %ld", (long) ptptype->DATA);
576 if (ptlocon->PNODE != NULL && complete) {
577 fprintf(ptfile, " (#");
578 for (ptnum = ptlocon->PNODE; ptnum; ptnum = ptnum->NEXT) {
579 fprintf(ptfile, " %ld", ptnum->DATA);
580 }
581 fprintf(ptfile, ")");
582 }
583 }
584 fprintf(ptfile, ")");
585 }
586 ptloins->LOCON = (locon_list *)reverse((chain_list *)ptloins->LOCON);
587 fprintf(ptfile, "))");
588 }
589 fprintf(ptfile, ")\n");
590
591 /* ---------------------------------------------------------------------------
592 Cone Netlist Structure cell list
593 --------------------------------------------------------------------------- */
594 if (ptcnsfig->CELL != NULL) {
595 fprintf(ptfile, "\n(CELLS");
596 counter = 0;
597 for (ptcell = ptcnsfig->CELL; ptcell != NULL; ptcell = ptcell->NEXT) {
598 if (ptcell->CONES == NULL) continue;
599 counter++;
600 if ((ptptype = getptype(ptcell->USER, (long) CNS_INDEX)) != NULL) {
601 ptptype->DATA = (void *) counter;
602 }
603 else {
604 ptcell->USER = addptype(ptcell->USER, (long) CNS_INDEX, (void *) counter);
605 }
606 fprintf(ptfile, "\n\n(%ld", counter);
607 strcpy(cell_type, "");
608 if ((ptcell->TYPE & CNS_UNKNOWN) == CNS_UNKNOWN) {
609 if (ptcell->TYPE != 0) {
610 fprintf(ptfile, " %ld", (ptcell->TYPE & ~CNS_UNKNOWN));
611 }
612 else {
613 strcat(cell_type, "?");
614 error = 1;
615 }
616 }
617 else {
618 if ((ptcell->TYPE & CNS_SUPER_BUFFER) == CNS_SUPER_BUFFER)
619 strcat(cell_type, "Super_Buffer");
620 else if ((ptcell->TYPE & CNS_TRISTATE_E) == CNS_TRISTATE_E)
621 strcat(cell_type, "Tristate");
622 else if ((ptcell->TYPE & CNS_SQUIRT_BUFFER) == CNS_SQUIRT_BUFFER)
623 strcat(cell_type, "Squirt_Buffer");
624 else if ((ptcell->TYPE & CNS_LATCH_E) == CNS_LATCH_E)
625 strcat(cell_type, "Latch");
626 else if ((ptcell->TYPE & CNS_READ) == CNS_READ)
627 strcat(cell_type, "Read");
628 else if ((ptcell->TYPE & CNS_MS_FF) == CNS_MS_FF)
629 strcat(cell_type, "Ms_Ff");
630 if (strlen(cell_type) == 0) {
631 strcat(cell_type, "?");
632 error = 1;
633 }
634 fprintf(ptfile, " %s", cell_type);
635 }
636 if ((ptchain = ptcell->CONES) != NULL) {
637 fprintf(ptfile, "\n(%ld", ((cone_list *) ptchain->DATA)->INDEX);
638 counter1 = 1;
639 for (ptchain = ptchain->NEXT; ptchain != NULL; ptchain = ptchain->NEXT) {
640 if (counter1++ == 9) {
641 fprintf(ptfile, "\n");
642 counter1 = 1;
643 }
644 if (ptchain->DATA != NULL) {
645 fprintf(ptfile, " %ld", ((cone_list *) ptchain->DATA)->INDEX);
646 }
647 else {
648 fprintf(ptfile, " ?");
649 error = 1;
650 }
651 }
652 }
653 else {
654 fprintf(ptfile, "\n(?");
655 error = 1;
656 }
657 fprintf(ptfile, "))");
658 }
659 fprintf(ptfile, ")\n");
660 }
661
662 /* ---------------------------------------------------------------------------
663 Cone Netlist Structure cone list
664 --------------------------------------------------------------------------- */
665 fprintf(ptfile, "\n(CONES");
666 for (ptcone0 = ptcnsfig->CONE; ptcone0 != NULL; ptcone0 = ptcone0->NEXT) {
667 if (strchr(ptcone0->NAME, ' ') != NULL) {
668 fprintf(ptfile, "\n\n(%ld \"%s\"", ptcone0->INDEX, ptcone0->NAME);
669 }
670 else fprintf(ptfile, "\n\n(%ld %s", ptcone0->INDEX, ptcone0->NAME);
671 strcpy(cone_type, "");
672 if ((ptcone0->TYPE & CNS_MEMSYM) == CNS_MEMSYM)
673 strcat(cone_type, "M");
674 if ((ptcone0->TYPE & CNS_LATCH) == CNS_LATCH)
675 strcat(cone_type, "L");
676 if ((ptcone0->TYPE & CNS_RS) == CNS_RS)
677 strcat(cone_type, "S");
678 if ((ptcone0->TYPE & CNS_FLIP_FLOP) == CNS_FLIP_FLOP)
679 strcat(cone_type, "F");
680 if ((ptcone0->TYPE & CNS_MASTER) == CNS_MASTER)
681 strcat(cone_type, "m");
682 if ((ptcone0->TYPE & CNS_SLAVE) == CNS_SLAVE)
683 strcat(cone_type, "e");
684 if ((ptcone0->TYPE & CNS_PRECHARGE) == CNS_PRECHARGE)
685 strcat(cone_type, "P");
686 if ((ptcone0->TYPE & CNS_TRI) == CNS_TRI)
687 strcat(cone_type, "T");
688 if ((ptcone0->TYPE & CNS_CONFLICT) == CNS_CONFLICT)
689 strcat(cone_type, "C");
690 if ((ptcone0->TYPE & CNS_EXT) == CNS_EXT)
691 strcat(cone_type, "Ext");
692 if ((ptcone0->TYPE & CNS_VDD) == CNS_VDD)
693 strcat(cone_type, "Vdd");
694 if ((ptcone0->TYPE & CNS_GND) == CNS_GND)
695 strcat(cone_type, "Gnd");
696 if ((ptcone0->TYPE & CNS_VSS) == CNS_VSS)
697 strcat(cone_type, "Vss");
698 /* if (strlen(cone_type) == 0) {
699 strcat(cone_type, "?");
700 error = 1;
701 } */
702 fprintf(ptfile, " %s -", cone_type);
703
704 strcpy(cone_tectype, "");
705 if ((ptcone0->TECTYPE & CNS_DUAL_CMOS) == CNS_DUAL_CMOS)
706 strcat(cone_tectype, "dC");
707 else if ((ptcone0->TECTYPE & CNS_CMOS) == CNS_CMOS)
708 strcat(cone_tectype, "Cm");
709 if ((ptcone0->TECTYPE & CNS_VDD_DEGRADED) == CNS_VDD_DEGRADED)
710 strcat(cone_tectype, "VddD");
711 if ((ptcone0->TECTYPE & CNS_GND_DEGRADED) == CNS_GND_DEGRADED)
712 strcat(cone_tectype, "GndD");
713 if ((ptcone0->TECTYPE & CNS_VSS_DEGRADED) == CNS_VSS_DEGRADED)
714 strcat(cone_tectype, "VssD");
715 if ((ptcone0->TECTYPE & CNS_NOR) == CNS_NOR)
716 strcat(cone_tectype, "Nor");
717 if ((ptcone0->TECTYPE & CNS_OR) == CNS_OR)
718 strcat(cone_tectype, "Or");
719 if ((ptcone0->TECTYPE & CNS_PR_NOR) == CNS_PR_NOR)
720 strcat(cone_tectype, "Pr_Nor");
721 if ((ptcone0->TECTYPE & CNS_NAND) == CNS_NAND)
722 strcat(cone_tectype, "Nand");
723 if ((ptcone0->TECTYPE & CNS_SBE) == CNS_SBE)
724 strcat(cone_tectype, "Sbe");
725 if ((ptcone0->TECTYPE & CNS_SBD) == CNS_SBD)
726 strcat(cone_tectype, "Sbd");
727 if ((ptcone0->TECTYPE & CNS_TRISTATE_O) == CNS_TRISTATE_O)
728 strcat(cone_tectype, "Tristate_o");
729 if ((ptcone0->TECTYPE & CNS_SQUIRT_O) == CNS_SQUIRT_O)
730 strcat(cone_tectype, "Squirt_o");
731 if ((ptcone0->TECTYPE & CNS_LATCH_O) == CNS_LATCH_O)
732 strcat(cone_tectype, "Latch_o");
733 if ((ptcone0->TECTYPE & CNS_PR_BUS) == CNS_PR_BUS)
734 strcat(cone_tectype, "Pr_Bus");
735 if ((ptcone0->TECTYPE & CNS_ZERO) == CNS_ZERO)
736 strcat(cone_tectype, "Zero");
737 if ((ptcone0->TECTYPE & CNS_ONE) == CNS_ONE)
738 strcat(cone_tectype, "One");
739 if (strlen(cone_tectype) == 0) {
740 strcat(cone_tectype, "X");
741 }
742 fprintf(ptfile, " %s", cone_tectype);
743
744 #ifdef USEOLDTEMP
745 fprintf(ptfile, " %ld %ld %ld %ld", ptcone0->XM, ptcone0->Xm, ptcone0->YM, ptcone0->Ym);
746 #else
747 fprintf(ptfile, " %d %d %d %d", 0, 0, 0, 0);
748 #endif
749 /* ------------------------------------------------------------------------
750 cone inputs
751 ------------------------------------------------------------------------ */
752 fprintf(ptfile, "\n(INPUT");
753 if (ptcone0->INCONE != NULL) {
754 for (ptedge = ptcone0->INCONE; ptedge != NULL; ptedge = ptedge->NEXT) {
755 if ((ptedge->TYPE & CNS_CONE) == CNS_CONE) {
756 fprintf(ptfile, "\n(Cone");
757 ptcone1 = ptedge->UEDGE.CONE;
758 if (ptcone1 != NULL) {
759 if ((ptedge->TYPE & CNS_BLEEDER) == CNS_BLEEDER) {
760 fprintf(ptfile, " bleeder");
761 }
762 if ((ptedge->TYPE & CNS_COMMAND) == CNS_COMMAND) {
763 fprintf(ptfile, " command");
764 }
765 if ((ptedge->TYPE & CNS_ASYNC) == CNS_ASYNC) {
766 fprintf(ptfile, " async");
767 }
768 if ((ptedge->TYPE & CNS_LOOP) == CNS_LOOP) {
769 fprintf(ptfile, " loop");
770 }
771 if ((ptedge->TYPE & CNS_FEEDBACK) == CNS_FEEDBACK) {
772 fprintf(ptfile, " feedback");
773 }
774 if ((ptedge->TYPE & CNS_MEMSYM) == CNS_MEMSYM) {
775 fprintf(ptfile, " memsym");
776 }
777 if ((ptedge->TYPE & CNS_HZCOM) == CNS_HZCOM) {
778 fprintf(ptfile, " hz_command");
779 }
780 fprintf(ptfile, " %ld)", ptcone1->INDEX);
781 }
782 else {
783 fprintf(ptfile, " ?)");
784 error = 1;
785 }
786 }
787 else if ((ptedge->TYPE & CNS_VDD) == CNS_VDD) {
788 fprintf(ptfile, "\n(Vdd");
789 ptcone1 = ptedge->UEDGE.CONE;
790 if (ptcone1 != NULL) {
791 fprintf(ptfile, " %ld)", ptcone1->INDEX);
792 }
793 else {
794 fprintf(ptfile, " ?)");
795 error = 1;
796 }
797 }
798 else if ((ptedge->TYPE & CNS_GND) == CNS_GND) {
799 fprintf(ptfile, "\n(Gnd");
800 ptcone1 = ptedge->UEDGE.CONE;
801 if (ptcone1 != NULL) {
802 fprintf(ptfile, " %ld)", ptcone1->INDEX);
803 }
804 else {
805 fprintf(ptfile, " ?)");
806 error = 1;
807 }
808 }
809 else if ((ptedge->TYPE & CNS_VSS) == CNS_VSS) {
810 fprintf(ptfile, "\n(Vss");
811 ptcone1 = ptedge->UEDGE.CONE;
812 if (ptcone1 != NULL) {
813 fprintf(ptfile, " %ld)", ptcone1->INDEX);
814 }
815 else {
816 fprintf(ptfile, " ?)");
817 error = 1;
818 }
819 }
820 else if ((ptedge->TYPE & CNS_EXT) == CNS_EXT) {
821 fprintf(ptfile, "\n(Ext");
822 ptlocon = ptedge->UEDGE.LOCON;
823 if ((ptlocon != NULL) && ((ptptype = getptype(ptlocon->USER, (long) CNS_INDEX)) != NULL)) {
824 fprintf(ptfile, " %ld)", (long) ptptype->DATA);
825 }
826 else {
827 fprintf(ptfile, " ?)");
828 error = 1;
829 }
830 }
831 else {
832 fprintf(ptfile, "\n(? ?)");
833 error = 1;
834 }
835 }
836 }
837 fprintf(ptfile, ")");
838
839 /* ------------------------------------------------------------------------
840 cone outputs
841 ------------------------------------------------------------------------ */
842 fprintf(ptfile, "\n(OUTPUT");
843 if (ptcone0->OUTCONE != NULL) {
844 for (ptedge = ptcone0->OUTCONE; ptedge != NULL; ptedge = ptedge->NEXT) {
845 if ((ptedge->TYPE & CNS_CONE) == CNS_CONE) {
846 fprintf(ptfile, "\n(Cone");
847 ptcone1 = ptedge->UEDGE.CONE;
848 if (ptcone1 != NULL) {
849 if ((ptedge->TYPE & CNS_BLEEDER) == CNS_BLEEDER) {
850 fprintf(ptfile, " bleeder");
851 }
852 if ((ptedge->TYPE & CNS_COMMAND) == CNS_COMMAND) {
853 fprintf(ptfile, " command");
854 }
855 if ((ptedge->TYPE & CNS_ASYNC) == CNS_ASYNC) {
856 fprintf(ptfile, " async");
857 }
858 if ((ptedge->TYPE & CNS_LOOP) == CNS_LOOP) {
859 fprintf(ptfile, " loop");
860 }
861 if ((ptedge->TYPE & CNS_FEEDBACK) == CNS_FEEDBACK) {
862 fprintf(ptfile, " feedback");
863 }
864 if ((ptedge->TYPE & CNS_MEMSYM) == CNS_MEMSYM) {
865 fprintf(ptfile, " memsym");
866 }
867 fprintf(ptfile, " %ld)", ptcone1->INDEX);
868 }
869 else {
870 fprintf(ptfile, " ?)");
871 error = 1;
872 }
873 }
874 else if ((ptedge->TYPE & CNS_EXT) == CNS_EXT) {
875 fprintf(ptfile, "\n(Ext");
876 ptlocon = ptedge->UEDGE.LOCON;
877 if ((ptlocon != NULL) && ((ptptype = getptype(ptlocon->USER, (long) CNS_INDEX)) != NULL)) {
878 fprintf(ptfile, " %ld)", (long) ptptype->DATA);
879 }
880 else {
881 fprintf(ptfile, " ?)");
882 error = 1;
883 }
884 }
885 else {
886 fprintf(ptfile, "\n(? ?)");
887 error = 1;
888 }
889 }
890 }
891 fprintf(ptfile, ")");
892
893 /* ------------------------------------------------------------------------
894 cone branches
895 ------------------------------------------------------------------------ */
896 fprintf(ptfile, "\n(BRANCHES");
897 counter = 0;
898 for (ptbranch = ptcone0->BRVDD; ptbranch != NULL; ptbranch = ptbranch->NEXT) {
899 if (treatbr(ptfile, ptbranch, ++counter)) {
900 error = 1;
901 counter--;
902 }
903 }
904 for (ptbranch = ptcone0->BRGND; ptbranch != NULL; ptbranch = ptbranch->NEXT) {
905 if (treatbr(ptfile, ptbranch, ++counter)) {
906 error = 1;
907 counter--;
908 }
909 }
910 for (ptbranch = ptcone0->BRVSS; ptbranch != NULL; ptbranch = ptbranch->NEXT) {
911 if (treatbr(ptfile, ptbranch, ++counter)) {
912 error = 1;
913 counter--;
914 }
915 }
916 for (ptbranch = ptcone0->BREXT; ptbranch != NULL; ptbranch = ptbranch->NEXT) {
917 if (treatbr(ptfile, ptbranch, ++counter)) {
918 error = 1;
919 counter--;
920 }
921 }
922 fprintf(ptfile, ")");
923
924
925 /* ------------------------------------------------------------------------
926 cells containg the cone
927 ------------------------------------------------------------------------ */
928 if ((ptchain = ptcone0->CELLS) != NULL) {
929 fprintf(ptfile, "\n(CELLS");
930 if ((ptptype = getptype(((cell_list *) ptchain->DATA)->USER, (long) CNS_INDEX)) != NULL) {
931 fprintf(ptfile, "\n(%ld", (long) ptptype->DATA);
932 }
933 else {
934 fprintf(ptfile, "\n(?");
935 }
936 counter1 = 1;
937 for (ptchain = ptchain->NEXT; ptchain != NULL; ptchain = ptchain->NEXT) {
938 if (counter1++ == 9) {
939 fprintf(ptfile, "\n");
940 counter1 = 1;
941 }
942 if (ptchain->DATA != NULL) {
943 if ((ptptype = getptype(((cell_list *) ptchain->DATA)->USER, (long) CNS_INDEX)) != NULL) {
944 fprintf(ptfile, " %ld", (long) ptptype->DATA);
945 }
946 else {
947 fprintf(ptfile, " ?");
948 }
949 }
950 else {
951 fprintf(ptfile, " ?");
952 error = 1;
953 }
954 }
955 fprintf(ptfile, "))");
956 }
957
958 /* ------------------------------------------------------------------------
959 cone user fields
960 ------------------------------------------------------------------------ */
961 if (((getptype(ptcone0->USER, (long) CNS_PARALLEL)) != NULL)
962 || ((getptype(ptcone0->USER, (long) CNS_BLEEDER)) != NULL)
963 || ((getptype(ptcone0->USER, (long) CNS_SIGNATURE)) != NULL)
964 || ((getptype(ptcone0->USER, (long) CNS_SWITCH)) != NULL)
965 || getptype(ptcone0->USER, (long) CNS_SIGNAL) != NULL) {
966 fprintf(ptfile, "\n(USER");
967
968 /* ---------------------------------------------------------------------
969 cone parallel branches
970 --------------------------------------------------------------------- */
971 if ((ptptype = getptype(ptcone0->USER, (long) CNS_PARALLEL)) != NULL) {
972 if ((ptchain0 = (chain_list *) ptptype->DATA) != NULL) {
973 fprintf(ptfile, "\n(PARALLEL");
974 for (ptchain0 = ptchain0; ptchain0 != NULL; ptchain0 = ptchain0->NEXT) {
975 if (ptchain0->DATA != NULL) {
976 ptchain1 = (chain_list *) ptchain0->DATA;
977 if ((ptptype1 = getptype(((branch_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
978 fprintf(ptfile, "\n(%ld", (long) ptptype1->DATA);
979 }
980 else {
981 fprintf(ptfile, "\n(?");
982 }
983 counter1 = 1;
984 for (ptchain1 = ptchain1->NEXT; ptchain1 != NULL; ptchain1 = ptchain1->NEXT) {
985 if (counter1++ == 9) {
986 fprintf(ptfile, "\n");
987 counter1 = 1;
988 }
989 if ((ptptype1 = getptype(((branch_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
990 fprintf(ptfile, " %ld", (long) ptptype1->DATA);
991 }
992 else {
993 fprintf(ptfile, " ?");
994 }
995 }
996 fprintf(ptfile, ")");
997 }
998 }
999 fprintf(ptfile, ")");
1000 }
1001 }
1002
1003 /* ---------------------------------------------------------------------
1004 cone bleeders
1005 --------------------------------------------------------------------- */
1006 if ((ptptype = getptype(ptcone0->USER, (long) CNS_BLEEDER)) != NULL) {
1007 if ((ptchain0 = (chain_list *) ptptype->DATA) != NULL) {
1008 fprintf(ptfile, "\n(BLEEDER");
1009 if ((ptptype0 = getptype(((branch_list *) ptchain0->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1010 fprintf(ptfile, "\n(%ld", (long) ptptype0->DATA);
1011 }
1012 else {
1013 fprintf(ptfile, "\n(?");
1014 }
1015 counter1 = 1;
1016 for (ptchain1 = ptchain0->NEXT; ptchain1 != NULL; ptchain1 = ptchain1->NEXT) {
1017 if (counter1++ == 9) {
1018 fprintf(ptfile, "\n");
1019 counter1 = 1;
1020 }
1021 if ((ptptype1 = getptype(((branch_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1022 fprintf(ptfile, " %ld", (long) ptptype1->DATA);
1023 }
1024 else {
1025 fprintf(ptfile, " ?");
1026 }
1027 }
1028 fprintf(ptfile, "))");
1029 }
1030 }
1031
1032 /* ---------------------------------------------------------------------
1033 cone signature
1034 --------------------------------------------------------------------- */
1035 if ((ptptype = getptype(ptcone0->USER, (long) CNS_SIGNATURE)) != NULL) {
1036 if (ptptype->DATA != NULL) {
1037 fprintf(ptfile, "\n(SIGNATURE");
1038 fprintf(ptfile, "\n(%s", ((char *) ptptype->DATA));
1039 fprintf(ptfile, "))");
1040 }
1041 }
1042 /* ---------------------------------------------------------------------
1043 cone signal
1044 --------------------------------------------------------------------- */
1045 if ((ptptype = getptype(ptcone0->USER, (long) CNS_SIGNAL)) != NULL && ptlofig != NULL) {
1046 if (ptptype->DATA != NULL) {
1047 ptlosig = (losig_list *)ptptype->DATA;
1048 ptptype1 = getptype(ptlosig->USER, CNS_INDEX);
1049 fprintf(ptfile, "\n(SIGIDX");
1050 fprintf(ptfile, "\n(%ld", (long)ptptype1->DATA);
1051 fprintf(ptfile, "))");
1052 }
1053 }
1054 /* ---------------------------------------------------------------------
1055 cone switches
1056 --------------------------------------------------------------------- */
1057 if ((ptptype = getptype(ptcone0->USER, (long) CNS_SWITCH)) != NULL) {
1058 if ((ptchain0 = (chain_list *) ptptype->DATA) != NULL) {
1059 fprintf(ptfile, "\n(SWITCH\n");
1060 counter1 = 1;
1061 for (ptchain0 = ptchain0; ptchain0 != NULL; ptchain0 = ptchain0->NEXT) {
1062 if (counter1++ == 5) {
1063 fprintf(ptfile, "\n");
1064 counter1 = 1;
1065 }
1066 if ((ptchain1 = (chain_list *) ptchain0->DATA) != NULL) {
1067 if ((ptptype1 = getptype(((lotrs_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1068 fprintf(ptfile, " (%ld", (long) ptptype1->DATA);
1069 }
1070 else {
1071 fprintf(ptfile, " (?");
1072 }
1073 if ((ptchain1 = ptchain1->NEXT) != NULL) {
1074 if ((ptptype1 = getptype(((lotrs_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1075 fprintf(ptfile, " %ld)", (long) ptptype1->DATA);
1076 }
1077 else {
1078 fprintf(ptfile, " ?)");
1079 }
1080 }
1081 else {
1082 fprintf(ptfile, " ?)");
1083 }
1084 }
1085 else {
1086 fprintf(ptfile, " (? ?)");
1087 }
1088 }
1089 fprintf(ptfile, ")");
1090 }
1091 }
1092 /* ---------------------------------------------------------------------
1093 cone parallel transistors
1094 --------------------------------------------------------------------- */
1095 if ((ptptype = getptype(ptcone0->USER, (long) CNS_PARATRANS)) != NULL) {
1096 if ((ptchain0 = (chain_list *) ptptype->DATA) != NULL) {
1097 fprintf(ptfile, "\n(PARATRANS");
1098 for (ptchain0 = ptchain0; ptchain0 != NULL; ptchain0 = ptchain0->NEXT) {
1099 if (ptchain0->DATA != NULL) {
1100 ptchain1 = (chain_list *)getptype(((lotrs_list *)ptchain0->DATA)->USER, MBK_TRANS_PARALLEL)->DATA;
1101 if ((ptptype1 = getptype(((lotrs_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1102 fprintf(ptfile, "\n(%ld", (long) ptptype1->DATA);
1103 }
1104 else {
1105 fprintf(ptfile, "\n(?");
1106 }
1107 counter1 = 1;
1108 for (ptchain1 = ptchain1->NEXT; ptchain1 != NULL; ptchain1 = ptchain1->NEXT) {
1109 if (counter1++ == 9) {
1110 fprintf(ptfile, "\n");
1111 counter1 = 1;
1112 }
1113 if ((ptptype1 = getptype(((lotrs_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1114 fprintf(ptfile, " %ld", (long) ptptype1->DATA);
1115 }
1116 else {
1117 fprintf(ptfile, " ?");
1118 }
1119 }
1120 fprintf(ptfile, ")");
1121 }
1122 }
1123 fprintf(ptfile, ")");
1124 }
1125 }
1126
1127 /* ---------------------------------------------------------------------
1128 end of cone user fields
1129 --------------------------------------------------------------------- */
1130 fprintf(ptfile, ")");
1131 }
1132
1133 /* ------------------------------------------------------------------------
1134 end of cone
1135 ------------------------------------------------------------------------ */
1136 fprintf(ptfile, ")");
1137 }
1138
1139 /* ---------------------------------------------------------------------------
1140 end of cones
1141 --------------------------------------------------------------------------- */
1142 fprintf(ptfile, ")");
1143
1144 /* ---------------------------------------------------------------------------
1145 end of cnsfig
1146 --------------------------------------------------------------------------- */
1147 fprintf(ptfile, ")\n");
1148
1149 for (ptcell = ptcnsfig->CELL; ptcell != NULL; ptcell = ptcell->NEXT) {
1150 if (ptcell->CONES == NULL) continue;
1151 ptcell->USER = testanddelptype(ptcell->USER, (long) CNS_INDEX);
1152 }
1153 /* ---------------------------------------------------------------------------
1154 close file
1155 --------------------------------------------------------------------------- */
1156 if (error == 1) {
1157 (void) fflush(stdout);
1158 (void) fprintf(stderr, "*** cns warning ***");
1159 (void) fprintf(stderr, " savecnsfig(): unknown fields found (marked by '?')\n");
1160 }
1161
1162 if (fclose(ptfile) != 0) {
1163 (void) fflush(stdout);
1164 (void) fprintf(stderr, "*** cns error ***");
1165 (void) fprintf(stderr, " savecnsfig() impossible: can't close file %s.cns\n", ptcnsfig->NAME);
1166 if (CNS_TRACE_MODE >= CNS_TRACE)
1167 (void) printf("TRA_cns savecnsfig out\n");
1168 EXIT(-1);
1169 }
1170
1171 if (CNS_TRACE_MODE >= CNS_TRACE)
1172 (void) printf("TRA_cns savecnsfig out\n");
1173 }
1174
1175 /*============================================================================*
1176 | function treatbr(); |
1177 *============================================================================*/
1178 short
1179 treatbr(ptfile, ptbranch, counter)
1180 FILE *ptfile;
1181 branch_list *ptbranch;
1182 long counter;
1183
1184 {
1185 char branch_type[10];
1186 char lotrs_type[8];
1187 short error = 0;
1188 link_list *ptlink = NULL;
1189 lotrs_list *ptlotrs = NULL;
1190 ptype_list *ptptype = NULL;
1191 locon_list *ptlocon = NULL;
1192
1193 if (CNS_TRACE_MODE >= CNS_TRACE)
1194 (void) printf("TRA_cns treatbr\n");
1195
1196 if (ptbranch->LINK != NULL) {
1197 strcpy(branch_type, "");
1198 if ((ptbranch->TYPE & CNS_NOT_FUNCTIONAL) == CNS_NOT_FUNCTIONAL)
1199 strcat(branch_type, "Nf");
1200 if ((ptbranch->TYPE & CNS_NOT_UP) == CNS_NOT_UP)
1201 strcat(branch_type, "Nu");
1202 if ((ptbranch->TYPE & CNS_NOT_DOWN) == CNS_NOT_DOWN)
1203 strcat(branch_type, "Nd");
1204 if ((ptbranch->TYPE & CNS_BLEEDER) == CNS_BLEEDER)
1205 strcat(branch_type, "B");
1206 if ((ptbranch->TYPE & CNS_VDD_DEGRADED) == CNS_VDD_DEGRADED)
1207 strcat(branch_type, "Dd");
1208 if ((ptbranch->TYPE & CNS_VSS_DEGRADED) == CNS_VSS_DEGRADED)
1209 strcat(branch_type, "Ds");
1210 if ((ptbranch->TYPE & CNS_FEEDBACK) == CNS_FEEDBACK)
1211 strcat(branch_type, "F");
1212 if ((ptbranch->TYPE & CNS_NOTCONFLICTUAL) == CNS_NOTCONFLICTUAL)
1213 strcat(branch_type, "Nx");
1214 if ((ptbranch->TYPE & CNS_RESBRANCH) == CNS_RESBRANCH)
1215 strcat(branch_type, "R");
1216 if ((ptbranch->TYPE & CNS_IGNORE) == CNS_IGNORE)
1217 strcat(branch_type, "I");
1218 if ((ptbranch->TYPE & CNS_PARALLEL_INS) == CNS_PARALLEL_INS)
1219 strcat(branch_type, "p");
1220 else if ((ptbranch->TYPE & CNS_PARALLEL) == CNS_PARALLEL)
1221 strcat(branch_type, "P");
1222 if ((ptbranch->TYPE & CNS_VDD) == CNS_VDD)
1223 strcat(branch_type, "Vdd");
1224 if ((ptbranch->TYPE & CNS_GND) == CNS_GND)
1225 strcat(branch_type, "Gnd");
1226 if ((ptbranch->TYPE & CNS_VSS) == CNS_VSS)
1227 strcat(branch_type, "Vss");
1228 if ((ptbranch->TYPE & CNS_EXT) == CNS_EXT)
1229 strcat(branch_type, "Ext");
1230 if (strlen(branch_type) == 0) {
1231 strcat(branch_type, "?");
1232 error = 1;
1233 }
1234 if ((ptptype = getptype(ptbranch->USER, (long) CNS_INDEX)) != NULL) {
1235 ptptype->DATA = (void *) counter;
1236 }
1237 else {
1238 ptbranch->USER = addptype(ptbranch->USER, (long) CNS_INDEX, (void *) counter);
1239 }
1240 fprintf(ptfile, "\n(%ld %s", counter, branch_type);
1241 for (ptlink = ptbranch->LINK; ptlink != NULL; ptlink = ptlink->NEXT) {
1242 if ((ptlink->TYPE & CNS_EXT) != CNS_EXT) {
1243 strcpy(lotrs_type, "");
1244 if ((ptlink->TYPE & CNS_SW) == CNS_SW)
1245 strcat(lotrs_type, "S");
1246 if ((ptlink->TYPE & CNS_PULL) == CNS_PULL)
1247 strcat(lotrs_type, "P");
1248 if ((ptlink->TYPE & CNS_DRIV_PULL) == CNS_DRIV_PULL)
1249 strcat(lotrs_type, "p");
1250 if ((ptlink->TYPE & CNS_DIODE_UP) == CNS_DIODE_UP)
1251 strcat(lotrs_type, "DU");
1252 if ((ptlink->TYPE & CNS_DIODE_DOWN) == CNS_DIODE_DOWN)
1253 strcat(lotrs_type, "DD");
1254 if ((ptlink->TYPE & CNS_SHORT) == CNS_SHORT)
1255 strcat(lotrs_type, "X");
1256 if ((ptlink->TYPE & CNS_RESIST) == CNS_RESIST)
1257 strcat(lotrs_type, "R");
1258 if ((ptlink->TYPE & CNS_CAPA) == CNS_CAPA)
1259 strcat(lotrs_type, "C");
1260 if ((ptlink->TYPE & CNS_DIPOLE) == CNS_DIPOLE)
1261 strcat(lotrs_type, "d");
1262 if ((ptlink->TYPE & CNS_SWITCH) == CNS_SWITCH)
1263 strcat(lotrs_type, "_s");
1264 if ((ptlink->TYPE & CNS_COMMAND) == CNS_COMMAND)
1265 strcat(lotrs_type, "_c");
1266 if ((ptlink->TYPE & CNS_ASYNCLINK) == CNS_ASYNCLINK)
1267 strcat(lotrs_type, "_a");
1268 if (strlen(lotrs_type) == 0) {
1269 strcat(lotrs_type, "?");
1270 error = 1;
1271 }
1272 fprintf(ptfile, "\n(%s", lotrs_type);
1273 ptlotrs = ptlink->ULINK.LOTRS;
1274 if (ptlotrs != NULL) {
1275 if (strcmp(CNS_TECHNO, "edmesfet") == 0) {
1276 if (MLO_IS_TRANSN(ptlotrs->TYPE))
1277 fprintf(ptfile, " E");
1278 else if (MLO_IS_TRANSP(ptlotrs->TYPE))
1279 fprintf(ptfile, " D");
1280 else {
1281 fprintf(ptfile, " ?");
1282 error = 1;
1283 }
1284 }
1285 else if (strcmp(CNS_TECHNO, "npmosfet") == 0) {
1286 if (MLO_IS_TRANSN(ptlotrs->TYPE))
1287 fprintf(ptfile, " N");
1288 else if (MLO_IS_TRANSP(ptlotrs->TYPE))
1289 fprintf(ptfile, " P");
1290 else {
1291 fprintf(ptfile, " ?");
1292 error = 1;
1293 }
1294 }
1295 else {
1296 fprintf(ptfile, " ?");
1297 error = 1;
1298 }
1299 if ((ptptype = getptype(ptlotrs->USER, (long) CNS_INDEX)) != NULL) {
1300 fprintf(ptfile, " %ld", (long) ptptype->DATA);
1301 }
1302 else {
1303 fprintf(ptfile, " ?");
1304 error = 1;
1305 }
1306 }
1307 }
1308 else {
1309 if ((ptlink->TYPE & CNS_IN) == CNS_IN) {
1310 fprintf(ptfile, "\n(In");
1311 }
1312 else if ((ptlink->TYPE & CNS_INOUT) == CNS_INOUT) {
1313 fprintf(ptfile, "\n(InOut");
1314 }
1315 else {
1316 fprintf(ptfile, "\n(?");
1317 error = 1;
1318 }
1319 ptlocon = ptlink->ULINK.LOCON;
1320 if ((ptlocon != NULL) && ((ptptype = getptype(ptlocon->USER, (long) CNS_INDEX)) != NULL)) {
1321 fprintf(ptfile, " %ld", (long) ptptype->DATA);
1322 }
1323 else {
1324 fprintf(ptfile, " ?");
1325 error = 1;
1326 }
1327 }
1328 ptptype = getptype(ptlink->SIG->USER, CNS_INDEX);
1329 fprintf(ptfile, " %ld", (long) ptptype->DATA);
1330 fprintf(ptfile, ")");
1331 }
1332 fprintf(ptfile, ")");
1333 }
1334
1335 return (error);
1336 }
1337
1338 /*============================================================================*
1339 | function savecnvfig(); |
1340 | Verbose Cone Netlist driver |
1341 *============================================================================*/
1342 void
1343 savecnvfig(ptcnsfig)
1344 cnsfig_list *ptcnsfig;
1345 {
1346 FILE *ptfile;
1347 time_t counter;
1348 locon_list *ptlocon;
1349 short error = 0;
1350 lotrs_list *ptlotrs;
1351 ptype_list *ptptype;
1352 cone_list *ptcone;
1353 char lotrs_type[8];
1354 cell_list *ptcell;
1355 char cell_type[16];
1356 long counter1;
1357 chain_list *ptchain;
1358 cone_list *ptcone0;
1359 char cone_type[256];
1360 char cone_tectype[256];
1361 edge_list *ptedge;
1362 cone_list *ptcone1;
1363 branch_list *ptbranch;
1364 chain_list *ptchain0;
1365 ptype_list *ptptype0;
1366 chain_list *ptchain1;
1367 ptype_list *ptptype1;
1368 char buffer[2048];
1369
1370 if (CNS_TRACE_MODE >= CNS_TRACE)
1371 (void) printf("TRA_cns savecnsfig in\n");
1372
1373 /* ---------------------------------------------------------------------------
1374 open file
1375 --------------------------------------------------------------------------- */
1376
1377 if ((ptfile = mbkfopen(ptcnsfig->NAME, "cnv", WRITE_TEXT)) == NULL) {
1378 (void) fflush(stdout);
1379 (void) fprintf(stderr, "*** cns error ***");
1380 (void) fprintf(stderr, " savecnvfig() impossible: can't open file %s.cnv\n", ptcnsfig->NAME);
1381 if (CNS_TRACE_MODE >= CNS_TRACE)
1382 (void) printf("TRA_cns savecnvfig out\n");
1383 EXIT(-1);
1384 }
1385
1386 /* ---------------------------------------------------------------------------
1387 header
1388 --------------------------------------------------------------------------- */
1389
1390
1391 sprintf(buffer, "CNS V%s %s\n"
1392 "Figure: %s\n"
1393 "Netlist format: %s\n",
1394 CNS_VERSION, CNS_TECHNO, ptcnsfig->NAME, IN_LO);
1395
1396 avt_printExecInfo(ptfile, "*", buffer, "");
1397
1398 /* ---------------------------------------------------------------------------
1399 capacity scale
1400 --------------------------------------------------------------------------- */
1401 fprintf(ptfile, "\nCapacitance Scale: %ld\n", SCALE_X);
1402
1403 /* ---------------------------------------------------------------------------
1404 Cone Netlist Structure external connector list
1405 --------------------------------------------------------------------------- */
1406 counter = 0;
1407 fprintf(ptfile, "\nEXTERNAL CONNECTORS\n");
1408 for (ptlocon = ptcnsfig->LOCON; ptlocon != NULL; ptlocon = ptlocon->NEXT) {
1409 counter++;
1410 if ((ptptype = getptype(ptlocon->USER, (long) CNS_INDEX)) != NULL) {
1411 ptptype->DATA = (void *) counter;
1412 }
1413 else {
1414 ptlocon->USER = addptype(ptlocon->USER, (long) CNS_INDEX, (void *) counter);
1415 }
1416 if (strchr(ptlocon->NAME, ' ') != NULL) {
1417 fprintf(ptfile, "\n %ld) %s[%d]", counter, vectorradical(ptlocon->NAME), vectorindex(ptlocon->NAME));
1418 }
1419 else fprintf(ptfile, "\n %ld) %s", counter, ptlocon->NAME);
1420 if (ptlocon->DIRECTION == CNS_I)
1421 fprintf(ptfile, " (Input)");
1422 else if (ptlocon->DIRECTION == CNS_O)
1423 fprintf(ptfile, " (Output)");
1424 else if (ptlocon->DIRECTION == CNS_B)
1425 fprintf(ptfile, " (Bidirectional)");
1426 else if (ptlocon->DIRECTION == CNS_Z)
1427 fprintf(ptfile, " (Tristate output)");
1428 else if (ptlocon->DIRECTION == CNS_T)
1429 fprintf(ptfile, " (Bidirectional tristate)");
1430 else if (ptlocon->DIRECTION == CNS_X)
1431 fprintf(ptfile, " (Unknown)");
1432 else if (ptlocon->DIRECTION == CNS_VDDC)
1433 fprintf(ptfile, " (Vdd)");
1434 else if (ptlocon->DIRECTION == CNS_GNDC)
1435 fprintf(ptfile, " (Gnd)");
1436 else if (ptlocon->DIRECTION == CNS_VSSC)
1437 fprintf(ptfile, " (Vss)");
1438 else {
1439 fprintf(ptfile, " (?)");
1440 error = 1;
1441 }
1442 ptptype = getptype(ptlocon->USER, CNS_TYPELOCON);
1443 if (ptptype != NULL) {
1444 if (((long)ptptype->DATA & CNS_ONE) == CNS_ONE) fprintf(ptfile, " Stuck One");
1445 else if (((long)ptptype->DATA & CNS_ZERO) == CNS_ZERO) fprintf(ptfile, " Stuck Zero");
1446 }
1447 }
1448 fprintf(ptfile, "\n");
1449
1450 /* ---------------------------------------------------------------------------
1451 Cone Netlist Structure internal connector list
1452 --------------------------------------------------------------------------- */
1453 if (ptcnsfig->INTCON != NULL) {
1454 fprintf(ptfile, "\nCONNECTORS TO INSTANCES\n");
1455 for (ptlocon = ptcnsfig->INTCON; ptlocon != NULL; ptlocon = ptlocon->NEXT) {
1456 counter++;
1457 if ((ptptype = getptype(ptlocon->USER, (long) CNS_INDEX)) != NULL) {
1458 ptptype->DATA = (void *) counter;
1459 }
1460 else {
1461 ptlocon->USER = addptype(ptlocon->USER, (long) CNS_INDEX, (void *) counter);
1462 }
1463 if (strchr(ptlocon->NAME, ' ') != NULL) {
1464 fprintf(ptfile, "\n %ld) %s[%d]", counter, vectorradical(ptlocon->NAME), vectorindex(ptlocon->NAME));
1465 }
1466 else fprintf(ptfile, "\n %ld) %s", counter, ptlocon->NAME);
1467 if (ptlocon->DIRECTION == CNS_I)
1468 fprintf(ptfile, " (Input)");
1469 else if (ptlocon->DIRECTION == CNS_O)
1470 fprintf(ptfile, " (Output)");
1471 else if (ptlocon->DIRECTION == CNS_B)
1472 fprintf(ptfile, " (Bidirectional)");
1473 else if (ptlocon->DIRECTION == CNS_Z)
1474 fprintf(ptfile, " (Tristate output)");
1475 else if (ptlocon->DIRECTION == CNS_T)
1476 fprintf(ptfile, " (Bidirectional tristate)");
1477 else if (ptlocon->DIRECTION == CNS_X)
1478 fprintf(ptfile, " (Unknown)");
1479 else if (ptlocon->DIRECTION == CNS_VDDC)
1480 fprintf(ptfile, " (Vdd)");
1481 else if (ptlocon->DIRECTION == CNS_GNDC)
1482 fprintf(ptfile, " (Gnd)");
1483 else if (ptlocon->DIRECTION == CNS_VSSC)
1484 fprintf(ptfile, " (Vss)");
1485 else {
1486 fprintf(ptfile, " (?)");
1487 error = 1;
1488 }
1489 }
1490 fprintf(ptfile, "\n");
1491 }
1492
1493 /* ---------------------------------------------------------------------------
1494 Cone Netlist Structure transistor list
1495 --------------------------------------------------------------------------- */
1496 counter = 0;
1497 fprintf(ptfile, "\nTRANSISTORS\n");
1498 for (ptlotrs = ptcnsfig->LOTRS; ptlotrs != NULL; ptlotrs = ptlotrs->NEXT) {
1499 counter++;
1500 if ((ptptype = getptype(ptlotrs->USER, (long) CNS_INDEX)) != NULL) {
1501 ptptype->DATA = (void *) counter;
1502 }
1503 else {
1504 ptlotrs->USER = addptype(ptlotrs->USER, (long) CNS_INDEX, (void *) counter);
1505 }
1506 fprintf(ptfile, "\n %ld)", counter);
1507 if (ptlotrs->TRNAME != NULL) {
1508 if (isdigit((int)*(ptlotrs->TRNAME))) fprintf(ptfile, " cns_%s", ptlotrs->TRNAME);
1509 else fprintf(ptfile, " %s", ptlotrs->TRNAME);
1510 }
1511 else {
1512 fprintf(ptfile, " noname");
1513 }
1514 strcpy(lotrs_type, "");
1515 if (strcmp(CNS_TECHNO, "edmesfet") == 0) {
1516 if (MLO_IS_TRANSN(ptlotrs->TYPE))
1517 strcat(lotrs_type, "TE");
1518 else if (MLO_IS_TRANSP(ptlotrs->TYPE))
1519 strcat(lotrs_type, "TD");
1520 }
1521 else if (strcmp(CNS_TECHNO, "npmosfet") == 0) {
1522 if (MLO_IS_TRANSN(ptlotrs->TYPE))
1523 strcat(lotrs_type, "TN");
1524 else if (MLO_IS_TRANSP(ptlotrs->TYPE))
1525 strcat(lotrs_type, "TP");
1526 }
1527 if (strlen(lotrs_type) == 0) {
1528 strcat(lotrs_type, "?");
1529 error = 1;
1530 }
1531 fprintf(ptfile, ", Type %s", lotrs_type);
1532 if (ptlotrs->MODINDEX != EMPTYHT) fprintf(ptfile, " (%s)", getlotrsmodel(ptlotrs));
1533 if ((ptptype = getptype(ptlotrs->USER, (long) CNS_DRIVINGCONE)) != NULL) {
1534 fprintf(ptfile, " driven by '%s',", ((cone_list *)ptptype->DATA)->NAME);
1535 }
1536 else if ((ptptype = getptype(ptlotrs->USER, (long) CNS_LINKTYPE)) != NULL) {
1537 if (((long) ptptype->DATA & CNS_ACTIVE) == CNS_ACTIVE) {
1538 if ((ptcone = (cone_list *) ptlotrs->GRID) != NULL) {
1539 fprintf(ptfile, " driven by %ld,", ptcone->INDEX);
1540 }
1541 else {
1542 fprintf(ptfile, " driven by ?,");
1543 error = 1;
1544 }
1545 }
1546 else if (((long) ptptype->DATA & CNS_PULL) == CNS_PULL)
1547 fprintf(ptfile, " puller,");
1548 else if (((long) ptptype->DATA & (CNS_DIODE_UP & CNS_DIODE_DOWN)) == (CNS_DIODE_UP & CNS_DIODE_DOWN))
1549 fprintf(ptfile, " diode,");
1550 else if (((long) ptptype->DATA & CNS_RESIST) == CNS_RESIST)
1551 fprintf(ptfile, " resistance,");
1552 else if (((long) ptptype->DATA & CNS_CAPA) == CNS_CAPA)
1553 fprintf(ptfile, " capacity,");
1554 else {
1555 fprintf(ptfile, " ?");
1556 error = 1;
1557 }
1558 }
1559 else {
1560 fprintf(ptfile, " 0");
1561 }
1562 if (ptlotrs->X != LONG_MIN && ptlotrs->Y != LONG_MIN) {
1563 fprintf(ptfile, " Position = (%ld,%ld),", ptlotrs->X, ptlotrs->Y);
1564 }
1565 fprintf(ptfile, " Width=%ld, Length=%ld,", ptlotrs->WIDTH, ptlotrs->LENGTH);
1566 fprintf(ptfile, " PS=%ld, PD=%ld", ptlotrs->PS, ptlotrs->PD);
1567 fprintf(ptfile, " XS=%ld, XD=%ld", ptlotrs->XS, ptlotrs->XD);
1568 }
1569 fprintf(ptfile, "\n");
1570
1571 /* ---------------------------------------------------------------------------
1572 Cone Netlist Structure cell list
1573 --------------------------------------------------------------------------- */
1574 if (ptcnsfig->CELL != NULL) {
1575 fprintf(ptfile, "\nCELLS");
1576 counter = 0;
1577 for (ptcell = ptcnsfig->CELL; ptcell != NULL; ptcell = ptcell->NEXT) {
1578 if (ptcell->CONES == NULL) continue;
1579 counter++;
1580 if ((ptptype = getptype(ptcell->USER, (long) CNS_INDEX)) != NULL) {
1581 ptptype->DATA = (void *) counter;
1582 }
1583 else {
1584 ptcell->USER = addptype(ptcell->USER, (long) CNS_INDEX, (void *) counter);
1585 }
1586 fprintf(ptfile, "\n\n %ld)", counter);
1587 if ((ptcell->TYPE & CNS_UNKNOWN) == CNS_UNKNOWN) {
1588 if (ptcell->TYPE != 0) {
1589 fprintf(ptfile, " Model %ld", (ptcell->TYPE & ~CNS_UNKNOWN));
1590 }
1591 else {
1592 fprintf(ptfile, " Model ?");
1593 error = 1;
1594 }
1595 }
1596 else {
1597 strcpy(cell_type, "");
1598 if ((ptcell->TYPE & CNS_SUPER_BUFFER) == CNS_SUPER_BUFFER)
1599 strcat(cell_type, "Super_Buffer");
1600 else if ((ptcell->TYPE & CNS_TRISTATE_E) == CNS_TRISTATE_E)
1601 strcat(cell_type, "Tristate");
1602 else if ((ptcell->TYPE & CNS_SQUIRT_BUFFER) == CNS_SQUIRT_BUFFER)
1603 strcat(cell_type, "Squirt_Buffer");
1604 else if ((ptcell->TYPE & CNS_LATCH_E) == CNS_LATCH_E)
1605 strcat(cell_type, "Latch");
1606 else if ((ptcell->TYPE & CNS_READ) == CNS_READ)
1607 strcat(cell_type, "Read");
1608 else if ((ptcell->TYPE & CNS_MS_FF) == CNS_MS_FF)
1609 strcat(cell_type, "Ms_Ff");
1610 if (strlen(cell_type) == 0) {
1611 strcat(cell_type, "?");
1612 error = 1;
1613 }
1614 fprintf(ptfile, " %s", cell_type);
1615 }
1616 for (ptchain = ptcell->CONES; ptchain != NULL; ptchain = ptchain->NEXT) {
1617 if (ptchain->DATA != NULL) {
1618 fprintf(ptfile, "\n %s", ((cone_list *) ptchain->DATA)->NAME);
1619 }
1620 else {
1621 fprintf(ptfile, " ?");
1622 error = 1;
1623 }
1624 }
1625 }
1626 fprintf(ptfile, "\n");
1627 }
1628
1629 /* ---------------------------------------------------------------------------
1630 Cone Netlist Structure cone list
1631 --------------------------------------------------------------------------- */
1632 fprintf(ptfile, "\nCONES");
1633 for (ptcone0 = ptcnsfig->CONE; ptcone0 != NULL; ptcone0 = ptcone0->NEXT) {
1634 if (strchr(ptcone0->NAME, ' ') != NULL) {
1635 fprintf(ptfile, "\n\n%ld) %s[%d]", ptcone0->INDEX, vectorradical(ptcone0->NAME), vectorindex(ptcone0->NAME));
1636 }
1637 else fprintf(ptfile, "\n\n%ld) %s", ptcone0->INDEX, ptcone0->NAME);
1638 strcpy(cone_type, "");
1639 if ((ptcone0->TYPE & CNS_MEMSYM) == CNS_MEMSYM)
1640 strcat(cone_type, "MemSym,");
1641 if ((ptcone0->TYPE & CNS_LATCH) == CNS_LATCH)
1642 strcat(cone_type, "Latch,");
1643 if ((ptcone0->TYPE & CNS_RS) == CNS_RS)
1644 strcat(cone_type, "RS,");
1645 if ((ptcone0->TYPE & CNS_FLIP_FLOP) == CNS_FLIP_FLOP)
1646 strcat(cone_type, "Flip-Flop,");
1647 if ((ptcone0->TYPE & CNS_MASTER) == CNS_MASTER)
1648 strcat(cone_type, "Master,");
1649 if ((ptcone0->TYPE & CNS_SLAVE) == CNS_SLAVE)
1650 strcat(cone_type, "Slave,");
1651 if ((ptcone0->TYPE & CNS_PRECHARGE) == CNS_PRECHARGE)
1652 strcat(cone_type, "Precharge,");
1653 if ((ptcone0->TYPE & CNS_TRI) == CNS_TRI)
1654 strcat(cone_type, "Tristate,");
1655 if ((ptcone0->TYPE & CNS_CONFLICT) == CNS_CONFLICT)
1656 strcat(cone_type, "Conflict,");
1657 if ((ptcone0->TYPE & CNS_EXT) == CNS_EXT)
1658 strcat(cone_type, "External,");
1659 if ((ptcone0->TYPE & CNS_VDD) == CNS_VDD)
1660 strcat(cone_type, "Vdd,");
1661 if ((ptcone0->TYPE & CNS_GND) == CNS_GND)
1662 strcat(cone_type, "Gnd,");
1663 if ((ptcone0->TYPE & CNS_VSS) == CNS_VSS)
1664 strcat(cone_type, "Vss,");
1665 if (strlen(cone_type) > 0) cone_type[strlen(cone_type)-1] = '\0';
1666 fprintf(ptfile, "\n Type: %s", cone_type);
1667
1668 strcpy(cone_tectype, "");
1669 if ((ptcone0->TECTYPE & CNS_ZERO) == CNS_ZERO)
1670 strcat(cone_tectype, "Stuck Zero,");
1671 if ((ptcone0->TECTYPE & CNS_ONE) == CNS_ONE)
1672 strcat(cone_tectype, "Stuck One,");
1673 if ((ptcone0->TECTYPE & CNS_DUAL_CMOS) == CNS_DUAL_CMOS)
1674 strcat(cone_tectype, "CMOS dual,");
1675 else if ((ptcone0->TECTYPE & CNS_CMOS) == CNS_CMOS)
1676 strcat(cone_tectype, "CMOS,");
1677 if ((ptcone0->TECTYPE & CNS_VDD_DEGRADED) == CNS_VDD_DEGRADED)
1678 strcat(cone_tectype, "Degraded Vdd,");
1679 if ((ptcone0->TECTYPE & CNS_GND_DEGRADED) == CNS_GND_DEGRADED)
1680 strcat(cone_tectype, "Degraded Gnd,");
1681 if ((ptcone0->TECTYPE & CNS_VSS_DEGRADED) == CNS_VSS_DEGRADED)
1682 strcat(cone_tectype, "Degraded Vss,");
1683
1684 if (strlen(cone_tectype) > 0) cone_tectype[strlen(cone_tectype)-1] = '\0';
1685 fprintf(ptfile, "\n TecTytpe: %s", cone_tectype);
1686
1687 /* ------------------------------------------------------------------------
1688 cone inputs
1689 ------------------------------------------------------------------------ */
1690 fprintf(ptfile, "\n INPUTS");
1691 if (ptcone0->INCONE != NULL) {
1692 for (ptedge = ptcone0->INCONE; ptedge != NULL; ptedge = ptedge->NEXT) {
1693 if ((ptedge->TYPE & CNS_CONE) == CNS_CONE) {
1694 fprintf(ptfile, "\n Cone");
1695 ptcone1 = ptedge->UEDGE.CONE;
1696 if (ptcone1 != NULL) {
1697 if ((ptedge->TYPE & CNS_BLEEDER) == CNS_BLEEDER) {
1698 fprintf(ptfile, " bleeder");
1699 }
1700 if ((ptedge->TYPE & CNS_COMMAND) == CNS_COMMAND) {
1701 fprintf(ptfile, " command");
1702 }
1703 if ((ptedge->TYPE & CNS_ASYNC) == CNS_ASYNC) {
1704 fprintf(ptfile, " async");
1705 }
1706 if ((ptedge->TYPE & CNS_LOOP) == CNS_LOOP) {
1707 fprintf(ptfile, " loop");
1708 }
1709 if ((ptedge->TYPE & CNS_FEEDBACK) == CNS_FEEDBACK) {
1710 fprintf(ptfile, " feedback");
1711 }
1712 if ((ptedge->TYPE & CNS_MEMSYM) == CNS_MEMSYM) {
1713 fprintf(ptfile, " memsym");
1714 }
1715 if ((ptedge->TYPE & CNS_HZCOM) == CNS_HZCOM) {
1716 fprintf(ptfile, " hz_command");
1717 }
1718 fprintf(ptfile, " '%s' (Index=%ld)", ptcone1->NAME, ptcone1->INDEX);
1719 }
1720 else {
1721 fprintf(ptfile, " ?");
1722 error = 1;
1723 }
1724 }
1725 else if ((ptedge->TYPE & CNS_VDD) == CNS_VDD) {
1726 fprintf(ptfile, "\n Vdd");
1727 ptcone1 = ptedge->UEDGE.CONE;
1728 if (ptcone1 != NULL) {
1729 fprintf(ptfile, " '%s' (Index=%ld)", ptcone1->NAME, ptcone1->INDEX);
1730 }
1731 else {
1732 fprintf(ptfile, " ?");
1733 error = 1;
1734 }
1735 }
1736 else if ((ptedge->TYPE & CNS_GND) == CNS_GND) {
1737 fprintf(ptfile, "\n Gnd");
1738 ptcone1 = ptedge->UEDGE.CONE;
1739 if (ptcone1 != NULL) {
1740 fprintf(ptfile, " '%s' (Index=%ld)", ptcone1->NAME, ptcone1->INDEX);
1741 }
1742 else {
1743 fprintf(ptfile, " ?");
1744 error = 1;
1745 }
1746 }
1747 else if ((ptedge->TYPE & CNS_VSS) == CNS_VSS) {
1748 fprintf(ptfile, "\n Vss");
1749 ptcone1 = ptedge->UEDGE.CONE;
1750 if (ptcone1 != NULL) {
1751 fprintf(ptfile, " '%s' (Index=%ld)", ptcone1->NAME, ptcone1->INDEX);
1752 }
1753 else {
1754 fprintf(ptfile, " ?");
1755 error = 1;
1756 }
1757 }
1758 else if ((ptedge->TYPE & CNS_EXT) == CNS_EXT) {
1759 fprintf(ptfile, "\n Ext");
1760 ptlocon = ptedge->UEDGE.LOCON;
1761 if (ptlocon != NULL) {
1762 fprintf(ptfile, " '%s'", ptlocon->NAME);
1763 }
1764 else {
1765 fprintf(ptfile, " ?");
1766 error = 1;
1767 }
1768 }
1769 else {
1770 fprintf(ptfile, "\n ? ?");
1771 error = 1;
1772 }
1773 }
1774 }
1775
1776 /* ------------------------------------------------------------------------
1777 cone outputs
1778 ------------------------------------------------------------------------ */
1779 fprintf(ptfile, "\n OUTPUTS");
1780 if (ptcone0->OUTCONE != NULL) {
1781 for (ptedge = ptcone0->OUTCONE; ptedge != NULL; ptedge = ptedge->NEXT) {
1782 if ((ptedge->TYPE & CNS_CONE) == CNS_CONE) {
1783 fprintf(ptfile, "\n Cone");
1784 ptcone1 = ptedge->UEDGE.CONE;
1785 if (ptcone1 != NULL) {
1786 if ((ptedge->TYPE & CNS_BLEEDER) == CNS_BLEEDER) {
1787 fprintf(ptfile, " bleeder");
1788 }
1789 if ((ptedge->TYPE & CNS_COMMAND) == CNS_COMMAND) {
1790 fprintf(ptfile, " command");
1791 }
1792 if ((ptedge->TYPE & CNS_ASYNC) == CNS_ASYNC) {
1793 fprintf(ptfile, " async");
1794 }
1795 if ((ptedge->TYPE & CNS_LOOP) == CNS_LOOP) {
1796 fprintf(ptfile, " loop");
1797 }
1798 if ((ptedge->TYPE & CNS_FEEDBACK) == CNS_FEEDBACK) {
1799 fprintf(ptfile, " feedback");
1800 }
1801 if ((ptedge->TYPE & CNS_MEMSYM) == CNS_MEMSYM) {
1802 fprintf(ptfile, " memsym");
1803 }
1804 fprintf(ptfile, " '%s' (Index=%ld)", ptcone1->NAME, ptcone1->INDEX);
1805 }
1806 else {
1807 fprintf(ptfile, " ?");
1808 error = 1;
1809 }
1810 }
1811 else if ((ptedge->TYPE & CNS_EXT) == CNS_EXT) {
1812 fprintf(ptfile, "\n Ext");
1813 ptlocon = ptedge->UEDGE.LOCON;
1814 if (ptlocon != NULL) {
1815 fprintf(ptfile, " '%s'", ptlocon->NAME);
1816 }
1817 else {
1818 fprintf(ptfile, " ?");
1819 error = 1;
1820 }
1821 }
1822 else {
1823 fprintf(ptfile, "\n ? ?");
1824 error = 1;
1825 }
1826 }
1827 }
1828
1829 /* ------------------------------------------------------------------------
1830 cone branches
1831 ------------------------------------------------------------------------ */
1832 fprintf(ptfile, "\n BRANCHES");
1833 counter = 0;
1834 for (ptbranch = ptcone0->BRVDD; ptbranch != NULL; ptbranch = ptbranch->NEXT) {
1835 if (treatbrv(ptfile, ptbranch, ++counter)) {
1836 error = 1;
1837 counter--;
1838 }
1839 }
1840 for (ptbranch = ptcone0->BRGND; ptbranch != NULL; ptbranch = ptbranch->NEXT) {
1841 if (treatbrv(ptfile, ptbranch, ++counter)) {
1842 error = 1;
1843 counter--;
1844 }
1845 }
1846 for (ptbranch = ptcone0->BRVSS; ptbranch != NULL; ptbranch = ptbranch->NEXT) {
1847 if (treatbrv(ptfile, ptbranch, ++counter)) {
1848 error = 1;
1849 counter--;
1850 }
1851 }
1852 for (ptbranch = ptcone0->BREXT; ptbranch != NULL; ptbranch = ptbranch->NEXT) {
1853 if (treatbrv(ptfile, ptbranch, ++counter)) {
1854 error = 1;
1855 counter--;
1856 }
1857 }
1858
1859 /* ------------------------------------------------------------------------
1860 cells containg the cone
1861 ------------------------------------------------------------------------ */
1862 if ((ptchain = ptcone0->CELLS) != NULL) {
1863 fprintf(ptfile, "\n CELLS");
1864 if ((ptptype = getptype(((cell_list *) ptchain->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1865 fprintf(ptfile, "\n (%ld", (long) ptptype->DATA);
1866 }
1867 else {
1868 fprintf(ptfile, "\n (?");
1869 }
1870 counter1 = 1;
1871 for (ptchain = ptchain->NEXT; ptchain != NULL; ptchain = ptchain->NEXT) {
1872 if (counter1++ == 9) {
1873 fprintf(ptfile, "\n");
1874 counter1 = 1;
1875 }
1876 if (ptchain->DATA != NULL) {
1877 if ((ptptype = getptype(((cell_list *) ptchain->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1878 fprintf(ptfile, " %ld", (long) ptptype->DATA);
1879 }
1880 else {
1881 fprintf(ptfile, " ?");
1882 }
1883 }
1884 else {
1885 fprintf(ptfile, " ?");
1886 error = 1;
1887 }
1888 }
1889 fprintf(ptfile, ")");
1890 }
1891
1892 /* ------------------------------------------------------------------------
1893 cone user fields
1894 ------------------------------------------------------------------------ */
1895 if (((getptype(ptcone0->USER, (long) CNS_PARALLEL)) != NULL)
1896 || ((getptype(ptcone0->USER, (long) CNS_BLEEDER)) != NULL)
1897 || ((getptype(ptcone0->USER, (long) CNS_PARATRANS)) != NULL)
1898 || ((getptype(ptcone0->USER, (long) CNS_SWITCH)) != NULL)) {
1899 fprintf(ptfile, "\n MISCELLANEOUS");
1900
1901 /* ---------------------------------------------------------------------
1902 cone parallel branches
1903 --------------------------------------------------------------------- */
1904 if ((ptptype = getptype(ptcone0->USER, (long) CNS_PARALLEL)) != NULL) {
1905 if ((ptchain0 = (chain_list *) ptptype->DATA) != NULL) {
1906 fprintf(ptfile, "\n PARALLEL BRANCHES");
1907 for (ptchain0 = ptchain0; ptchain0 != NULL; ptchain0 = ptchain0->NEXT) {
1908 if (ptchain0->DATA != NULL) {
1909 ptchain1 = (chain_list *) ptchain0->DATA;
1910 if ((ptptype1 = getptype(((branch_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1911 fprintf(ptfile, "\n (%ld", (long) ptptype1->DATA);
1912 }
1913 else {
1914 fprintf(ptfile, "\n (?");
1915 }
1916 for (ptchain1 = ptchain1->NEXT; ptchain1 != NULL; ptchain1 = ptchain1->NEXT) {
1917 if ((ptptype1 = getptype(((branch_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1918 fprintf(ptfile, " %ld", (long) ptptype1->DATA);
1919 }
1920 else {
1921 fprintf(ptfile, " ?");
1922 }
1923 }
1924 fprintf(ptfile, ")");
1925 }
1926 }
1927 }
1928 }
1929
1930 /* ---------------------------------------------------------------------
1931 cone bleeders
1932 --------------------------------------------------------------------- */
1933 if ((ptptype = getptype(ptcone0->USER, (long) CNS_BLEEDER)) != NULL) {
1934 if ((ptchain0 = (chain_list *) ptptype->DATA) != NULL) {
1935 fprintf(ptfile, "\n BLEEDER BRANCHES");
1936 if ((ptptype0 = getptype(((branch_list *) ptchain0->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1937 fprintf(ptfile, "\n (%ld", (long) ptptype0->DATA);
1938 }
1939 else {
1940 fprintf(ptfile, "\n (?");
1941 }
1942 for (ptchain1 = ptchain0->NEXT; ptchain1 != NULL; ptchain1 = ptchain1->NEXT) {
1943 if ((ptptype1 = getptype(((branch_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1944 fprintf(ptfile, " %ld", (long) ptptype1->DATA);
1945 }
1946 else {
1947 fprintf(ptfile, " ?");
1948 }
1949 }
1950 fprintf(ptfile, ")");
1951 }
1952 }
1953
1954 /* ---------------------------------------------------------------------
1955 cone switches
1956 --------------------------------------------------------------------- */
1957 if ((ptptype = getptype(ptcone0->USER, (long) CNS_SWITCH)) != NULL) {
1958 if ((ptchain0 = (chain_list *) ptptype->DATA) != NULL) {
1959 fprintf(ptfile, "\n SWITCH TRANSISTOR PAIRS");
1960 counter1 = 1;
1961 for (ptchain0 = ptchain0; ptchain0 != NULL; ptchain0 = ptchain0->NEXT) {
1962 if ((ptchain1 = (chain_list *) ptchain0->DATA) != NULL) {
1963 if ((ptptype1 = getptype(((lotrs_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1964 fprintf(ptfile, "\n (%ld", (long) ptptype1->DATA);
1965 }
1966 else {
1967 fprintf(ptfile, "\n (?");
1968 }
1969 if ((ptchain1 = ptchain1->NEXT) != NULL) {
1970 if ((ptptype1 = getptype(((lotrs_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1971 fprintf(ptfile, " %ld)", (long) ptptype1->DATA);
1972 }
1973 else {
1974 fprintf(ptfile, " ?)");
1975 }
1976 }
1977 else {
1978 fprintf(ptfile, " ?)");
1979 }
1980 }
1981 else {
1982 fprintf(ptfile, " (? ?)\n");
1983 }
1984 }
1985 }
1986 }
1987 /* ---------------------------------------------------------------------
1988 cone parallel transistors
1989 --------------------------------------------------------------------- */
1990 if ((ptptype = getptype(ptcone0->USER, (long) CNS_PARATRANS)) != NULL) {
1991 if ((ptchain0 = (chain_list *) ptptype->DATA) != NULL) {
1992 fprintf(ptfile, "\n PARALLEL TRANSISTORS");
1993 for (ptchain0 = ptchain0; ptchain0 != NULL; ptchain0 = ptchain0->NEXT) {
1994 if (ptchain0->DATA != NULL) {
1995 ptchain1 = (chain_list *)getptype(((lotrs_list *)ptchain0->DATA)->USER, MBK_TRANS_PARALLEL)->DATA;
1996 if ((ptptype1 = getptype(((lotrs_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
1997 fprintf(ptfile, "\n (%ld", (long) ptptype1->DATA);
1998 }
1999 else {
2000 fprintf(ptfile, "\n (?");
2001 }
2002 for (ptchain1 = ptchain1->NEXT; ptchain1 != NULL; ptchain1 = ptchain1->NEXT) {
2003 if ((ptptype1 = getptype(((lotrs_list *) ptchain1->DATA)->USER, (long) CNS_INDEX)) != NULL) {
2004 fprintf(ptfile, " %ld", (long) ptptype1->DATA);
2005 }
2006 else {
2007 fprintf(ptfile, " ?");
2008 }
2009 }
2010 fprintf(ptfile, ")");
2011 }
2012 }
2013 }
2014 }
2015
2016 /* ---------------------------------------------------------------------
2017 end of cone user fields
2018 --------------------------------------------------------------------- */
2019 }
2020
2021 /* ------------------------------------------------------------------------
2022 end of cone
2023 ------------------------------------------------------------------------ */
2024 }
2025
2026 /* ---------------------------------------------------------------------------
2027 end of cones
2028 --------------------------------------------------------------------------- */
2029
2030 for (ptcell = ptcnsfig->CELL; ptcell != NULL; ptcell = ptcell->NEXT) {
2031 if (ptcell->CONES == NULL) continue;
2032 ptcell->USER = testanddelptype(ptcell->USER, (long) CNS_INDEX);
2033 }
2034
2035 /* ---------------------------------------------------------------------------
2036 close file
2037 --------------------------------------------------------------------------- */
2038 if (error == 1) {
2039 (void) fflush(stdout);
2040 (void) fprintf(stderr, "*** cns warning ***");
2041 (void) fprintf(stderr, " savecnvfig(): unknown fields found (marked by '?')\n");
2042 }
2043
2044 if (fclose(ptfile) != 0) {
2045 (void) fflush(stdout);
2046 (void) fprintf(stderr, "*** cns error ***");
2047 (void) fprintf(stderr, " savecnvfig() impossible: can't close file %s.cnv\n", ptcnsfig->NAME);
2048 if (CNS_TRACE_MODE >= CNS_TRACE)
2049 (void) printf("TRA_cns savecnvfig out\n");
2050 EXIT(-1);
2051 }
2052
2053 if (CNS_TRACE_MODE >= CNS_TRACE)
2054 (void) printf("TRA_cns savecnvfig out\n");
2055 }
2056
2057 /*============================================================================*
2058 | function treatbrv(); |
2059 *============================================================================*/
2060 short
2061 treatbrv(ptfile, ptbranch, counter)
2062 FILE *ptfile;
2063 branch_list *ptbranch;
2064 long counter;
2065
2066 {
2067 char branch_type[256];
2068 char lotrs_type[256];
2069 short error = 0;
2070 link_list *ptlink = NULL;
2071 lotrs_list *ptlotrs = NULL;
2072 ptype_list *ptptype = NULL;
2073 locon_list *ptlocon = NULL;
2074 ptype_list *ptuser;
2075
2076 if (CNS_TRACE_MODE >= CNS_TRACE)
2077 (void) printf("TRA_cns treatbr\n");
2078
2079 if (ptbranch->LINK != NULL) {
2080 if ((ptptype = getptype(ptbranch->USER, (long) CNS_INDEX)) != NULL) {
2081 ptptype->DATA = (void *) counter;
2082 }
2083 else {
2084 ptbranch->USER = addptype(ptbranch->USER, (long) CNS_INDEX, (void *) counter);
2085 }
2086 fprintf(ptfile, "\n %ld) ", counter);
2087
2088 if ((ptbranch->TYPE & CNS_VDD) == CNS_VDD)
2089 fprintf(ptfile, "Vdd");
2090 if ((ptbranch->TYPE & CNS_GND) == CNS_GND)
2091 fprintf(ptfile, "Gnd");
2092 if ((ptbranch->TYPE & CNS_VSS) == CNS_VSS)
2093 fprintf(ptfile, "Vss");
2094 if ((ptbranch->TYPE & CNS_EXT) == CNS_EXT)
2095 fprintf(ptfile, "Ext");
2096
2097 strcpy(branch_type, "");
2098 if ((ptbranch->TYPE & CNS_NOT_FUNCTIONAL) == CNS_NOT_FUNCTIONAL)
2099 strcat(branch_type, "Non-Functional,");
2100 if ((ptbranch->TYPE & CNS_NOT_UP) == CNS_NOT_UP)
2101 strcat(branch_type, "Non-Up,");
2102 if ((ptbranch->TYPE & CNS_NOT_DOWN) == CNS_NOT_DOWN)
2103 strcat(branch_type, "Non-Down,");
2104 if ((ptbranch->TYPE & CNS_BLEEDER) == CNS_BLEEDER)
2105 strcat(branch_type, "Bleeder,");
2106 if ((ptbranch->TYPE & CNS_VDD_DEGRADED) == CNS_VDD_DEGRADED)
2107 strcat(branch_type, "Vdd-Degraded,");
2108 if ((ptbranch->TYPE & CNS_VSS_DEGRADED) == CNS_VSS_DEGRADED)
2109 strcat(branch_type, "Vss-Degraded,");
2110 if ((ptbranch->TYPE & CNS_FEEDBACK) == CNS_FEEDBACK)
2111 strcat(branch_type, "Feedback,");
2112 if ((ptbranch->TYPE & CNS_NOTCONFLICTUAL) == CNS_NOTCONFLICTUAL)
2113 strcat(branch_type, "Non-Conflictual,");
2114 if ((ptbranch->TYPE & CNS_PARALLEL_INS) == CNS_PARALLEL_INS)
2115 strcat(branch_type, "Parallel instance,");
2116 else if ((ptbranch->TYPE & CNS_PARALLEL) == CNS_PARALLEL)
2117 strcat(branch_type, "Parallel,");
2118
2119 if (strlen(branch_type) > 0) {
2120 branch_type[strlen(branch_type)-1] = '\0';
2121 fprintf(ptfile, " (%s)", branch_type);
2122 }
2123
2124 for (ptlink = ptbranch->LINK; ptlink != NULL; ptlink = ptlink->NEXT) {
2125 if ((ptlink->TYPE & CNS_EXT) != CNS_EXT) {
2126 ptlotrs = ptlink->ULINK.LOTRS;
2127 if (ptlotrs != NULL) {
2128 if (strcmp(CNS_TECHNO, "edmesfet") == 0) {
2129 if (MLO_IS_TRANSN(ptlotrs->TYPE))
2130 fprintf(ptfile, "\n TE ");
2131 else if (MLO_IS_TRANSP(ptlotrs->TYPE))
2132 fprintf(ptfile, "\n TD ");
2133 else {
2134 fprintf(ptfile, "\n ?");
2135 error = 1;
2136 }
2137 }
2138 else if (strcmp(CNS_TECHNO, "npmosfet") == 0) {
2139 if (MLO_IS_TRANSN(ptlotrs->TYPE))
2140 fprintf(ptfile, "\n TN ");
2141 else if (MLO_IS_TRANSP(ptlotrs->TYPE))
2142 fprintf(ptfile, "\n TP ");
2143 else {
2144 fprintf(ptfile, "\n ? ");
2145 error = 1;
2146 }
2147 }
2148 else {
2149 fprintf(ptfile, "\n ? ");
2150 error = 1;
2151 }
2152 if (ptlotrs->TRNAME != NULL) {
2153 fprintf(ptfile, "%s ", ptlotrs->TRNAME);
2154 }
2155 if ((ptptype = getptype(ptlotrs->USER, (long) CNS_INDEX)) != NULL) {
2156 fprintf(ptfile, "(Index=%ld) ", (long)ptptype->DATA);
2157 }
2158
2159 strcpy(lotrs_type, "");
2160 if ((ptlink->TYPE & CNS_DIODE_UP) == CNS_DIODE_UP)
2161 strcat(lotrs_type, "Diode Up,");
2162 if ((ptlink->TYPE & CNS_DIODE_DOWN) == CNS_DIODE_DOWN)
2163 strcat(lotrs_type, "Diode Down,");
2164 if ((ptlink->TYPE & CNS_RESIST) == CNS_RESIST)
2165 strcat(lotrs_type, "Resist,");
2166 if ((ptlink->TYPE & CNS_CAPA) == CNS_CAPA)
2167 strcat(lotrs_type, "Capa,");
2168 if ((ptlink->TYPE & CNS_SWITCH) == CNS_SWITCH)
2169 strcat(lotrs_type, "Switch,");
2170 if ((ptlink->TYPE & CNS_COMMAND) == CNS_COMMAND)
2171 strcat(lotrs_type, "Command,");
2172 if ((ptlink->TYPE & CNS_ASYNCLINK) == CNS_ASYNCLINK)
2173 strcat(lotrs_type, "Async,");
2174
2175 if (strlen(lotrs_type) > 0) {
2176 lotrs_type[strlen(lotrs_type)-1] = '\0';
2177 fprintf(ptfile, "(%s) ", lotrs_type);
2178 }
2179
2180 ptuser = getptype(ptlotrs->USER, CNS_DRIVINGCONE);
2181 if (ptuser != NULL) {
2182 fprintf(ptfile, "Driven by '%s' (Index=%ld)", ((cone_list *)ptuser->DATA)->NAME, ((cone_list *)ptuser->DATA)->INDEX);
2183 }
2184
2185 }
2186 }
2187 else {
2188 if ((ptlink->TYPE & CNS_IN) == CNS_IN) {
2189 fprintf(ptfile, "\n In");
2190 }
2191 else if ((ptlink->TYPE & CNS_INOUT) == CNS_INOUT) {
2192 fprintf(ptfile, "\n InOut");
2193 }
2194 else {
2195 fprintf(ptfile, "\n ?");
2196 error = 1;
2197 }
2198 ptlocon = ptlink->ULINK.LOCON;
2199 if (ptlocon != NULL) {
2200 fprintf(ptfile, " %s, ", ptlocon->NAME);
2201 }
2202 else {
2203 fprintf(ptfile, " ?, ");
2204 error = 1;
2205 }
2206 }
2207 }
2208 }
2209
2210 return (error);
2211 }
2212