1
2 /*
3 * $Id: util_MBK.c,v 1.5 2005/02/17 15:34:44 jpc Exp $
4 *
5 * /----------------------------------------------------------------\
6 * | |
7 * | A l l i a n c e C A D S y s t e m |
8 * | S i l i c o n E n s e m b l e / A l l i a n c e |
9 * | |
10 * | Author : Jean-Paul CHAPUT |
11 * | E-mail : alliance-users@asim.lip6.fr |
12 * | ============================================================== |
13 * | C Module : "./util_MBK.c" |
14 * | ************************************************************** |
15 * | U p d a t e s |
16 * | |
17 * \----------------------------------------------------------------/
18 */
19
20
21 # include "util_Defs.h"
22 # include "debugoff.h"
23
24
25 # define C_POWER_VDD (0)
26 # define C_POWER_VSS (1)
27 # define C_POWER_UNKNOWN (1024)
28
29 # define TLOSEG_SIZE (512)
30
31 # define SIZE_SNAME (1024)
32
33
34 /* ------------------------------------------------------------------
35 * Internal types.
36 */
37
38 typedef struct sigalias_s {
39 char *name; /* The main signal name (getsigname()). */
40 long flags; /* The subnet field. */
41 } sigalias_t;
42
43
44
45 /* ------------------------------------------------------------------
46 * Global variables (declared `extern' in "util_Defs.h").
47 */
48
49 long MBK_sigIndex = 0L;
50
51
52 /* ------------------------------------------------------------------
53 * Local variables.
54 */
55
56 static authtable *LV_htSigAlias = NULL;
57 static struct sigalias_s *LV_tSigAlias = NULL;
58
59
60 /* ------------------------------------------------------------------
61 * Local functions declarations.
62 */
63
64 static void buildtsigalias __FP((struct losig *apLosig));
65 static void freetsigalias __FP((void));
66
67 static char *getlosegname __FP((struct eLoseg_s *apLoseg));
68
69
70 /*
71 * /----------------------------------------------------------------\
72 * | Functions Definitions |
73 * \----------------------------------------------------------------/
74 */
75
76 /* ------------------------------------------------------------------
77 * Function : "isobs()".
78 */
79
isobs(apSeg)80 extern long isobs(apSeg)
81 struct phseg *apSeg;
82 {
83 switch (apSeg->LAYER) {
84 case TALU1:
85 case TALU2:
86 case TALU3:
87 case TALU4:
88 case TALU5:
89 case TALU6:
90 case TALU7:
91 case TALU8:
92 case TALU9:
93 return (TRUE);
94 }
95
96 return (FALSE);
97 }
98
99
100 /* ------------------------------------------------------------------
101 * Function : "getsigaliasnumber()".
102 */
103
getsigaliasnumber(apLosig)104 extern long getsigaliasnumber(apLosig)
105 struct losig *apLosig;
106 {
107 struct chain *pChain;
108 long aliasNumber;
109
110
111 aliasNumber = 0;
112
113 for (pChain = apLosig->NAMECHAIN; pChain != NULL; pChain = pChain->NEXT) {
114 aliasNumber++;
115 }
116
117 return (aliasNumber - 1);
118 }
119
120
121 /* ------------------------------------------------------------------
122 * Function : "signamecmp()".
123 */
124
125 extern long signamecmp(aLoname, aPhname)
126 char *aLoname, *aPhname;
127 {
128 char *pS, *pVector;
129 char losigName[SIZE_SNAME];
130
131
132 if (aLoname == aPhname) return (TRUE);
133
134 /* Try to guess if the losig name was a vector name. */
135 strcpy (losigName, aLoname);
136
137 pVector = NULL;
138 for (pS = losigName; pS != '\0'; pS++)
139 if (*pS == '_') pVector = pS;
140
141 if (!pVector) return (FALSE);
142
143 for (pS = pVector + 1; pS != '\0'; pS++)
144 if (!isdigit ((int)*pS)) return (FALSE);
145
146 *pVector = ' ';
147
148 if (!strcmp (losigName, aPhname)) return (TRUE);
149
150 return (FALSE);
151 }
152
153
154 /* ------------------------------------------------------------------
155 * Function : "makesegnamelist()".
156 */
157
158 extern char **makesegnamelist(aName)
159 char *aName;
160 {
161 static char *tSegAlias[1024];
162 long mSegAlias;
163 char *pS;
164 char losegName[SIZE_SNAME];
165 # if 0
166 char *pVector;
167 char pathName[SIZE_SNAME];
168 # endif
169 long iEnd;
170
171
172 mSegAlias = 0;
173 strcpy (losegName, aName);
174 iEnd = strlen (losegName) - 1;
175
176
177 /* Add the signal name "as is". */
178 tSegAlias[mSegAlias++] = namealloc (losegName);
179
180 #if 0
181 /* Try to find if it is a vector. */
182 pVector = NULL;
183 #endif
184 for (pS = losegName + iEnd; pS != losegName; pS--) {
185 if (*pS == ' ') {
186 *pS = '_';
187 tSegAlias[mSegAlias++] = namealloc (losegName);
188 }
189 }
190
191
192 # if 0
193 /* This code is no longer needed, for we. */
194 /* Loop on the path name, using SEPAR. */
195 for (; iEnd > 0; iEnd--) {
196 if (losegName[iEnd] == SEPAR) {
197 strncpy (pathName, losegName, iEnd);
198 pathName[iEnd] = '\0';
199
200 /* Add the path name "as is". */
201 tSegAlias[mSegAlias++] = pathName;
202
203 /* Try to find if it is a vector. */
204 pVector = NULL;
205 for (pS = pathName + iEnd; pS != pathName; pS--) {
206 if (*pS == ' ') {
207 *pS = '_';
208 tSegAlias[mSegAlias++] = pathName;
209 }
210 }
211 }
212 } /* End of "iEnd" loop. */
213 # endif
214
215
216 tSegAlias[mSegAlias++] = NULL;
217
218 return (tSegAlias);
219 }
220
221
222 /* ------------------------------------------------------------------
223 * Function : "printMBKEnv()".
224 */
225
printMBKEnv()226 extern void printMBKEnv()
227 {
228 int i;
229
230 mprintf2 (" o MBK environment :\n\n" );
231 mprintf2 (" MBK_IN_LO := %s\n", IN_LO );
232 mprintf2 (" MBK_OUT_LO := %s\n", OUT_LO );
233 mprintf2 (" MBK_IN_PH := %s\n", IN_PH );
234 mprintf2 (" MBK_OUT_PH := %s\n", OUT_PH );
235 mprintf2 (" MBK_WORK_LIB := %s\n", WORK_LIB);
236
237 for(i = 0; CATA_LIB[i] != (char *)NULL; i++) {
238 if (i == 0) mprintf2 (" MBK_CATA_LIB := ");
239 else mprintf2 (" ");
240 mprintf2 ("%s\n", CATA_LIB[i]);
241 }
242
243 mprintf2 (" MBK_CATAL_NAME := %s\n", CATAL);
244 mprintf2 (" MBK_VDD := %s\n", VDD );
245 mprintf2 (" MBK_VSS := %s\n", VSS );
246 mprintf2 (" MBK_SEPAR := %c\n", SEPAR);
247 mprintf2 ("\n");
248 }
249
250
251 /* ------------------------------------------------------------------
252 * Function : "getAltVIALayer()".
253 */
254
255 extern char getAltVIALayer(aVIA, aLayer)
256 char aVIA, aLayer;
257 {
258 char topLayer, bottomLayer, topCLayer, bottomCLayer, dualLayer;
259
260
261 topLayer = ALU1;
262 bottomLayer = ALU2;
263 topCLayer = CALU1;
264 bottomCLayer = CALU2;
265
266 switch (aVIA) {
267 case CONT_POLY:
268 topLayer = ALU1; bottomLayer = POLY;
269 topCLayer = CALU1; bottomCLayer = POLY;
270 break;
271 case CONT_VIA:
272 topLayer = ALU2; bottomLayer = ALU1;
273 topCLayer = CALU2; bottomCLayer = CALU1;
274 break;
275 case CONT_VIA2:
276 topLayer = ALU3; bottomLayer = ALU2;
277 topCLayer = CALU3; bottomCLayer = CALU2;
278 break;
279 case CONT_VIA3:
280 topLayer = ALU4; bottomLayer = ALU3;
281 topCLayer = CALU4; bottomCLayer = CALU3;
282 break;
283 case CONT_VIA4:
284 topLayer = ALU5; bottomLayer = ALU4;
285 topCLayer = CALU5; bottomCLayer = CALU4;
286 break;
287 case CONT_VIA5:
288 topLayer = ALU6; bottomLayer = ALU5;
289 topCLayer = CALU6; bottomCLayer = CALU5;
290 break;
291 case CONT_VIA6:
292 topLayer = ALU7; bottomLayer = ALU6;
293 topCLayer = CALU7; bottomCLayer = CALU6;
294 break;
295 case CONT_VIA7:
296 topLayer = ALU8; bottomLayer = ALU7;
297 topCLayer = CALU8; bottomCLayer = CALU7;
298 break;
299 case CONT_VIA8:
300 topLayer = ALU9; bottomLayer = ALU8;
301 topCLayer = CALU9; bottomCLayer = CALU8;
302 break;
303 case CONT_TURN1:
304 topLayer = ALU1; bottomLayer = ALU1;
305 topCLayer = CALU1; bottomCLayer = CALU1;
306 break;
307 case CONT_TURN2:
308 topLayer = ALU2; bottomLayer = ALU2;
309 topCLayer = CALU2; bottomCLayer = CALU2;
310 break;
311 case CONT_TURN3:
312 topLayer = ALU3; bottomLayer = ALU3;
313 topCLayer = CALU3; bottomCLayer = CALU3;
314 break;
315 case CONT_TURN4:
316 topLayer = ALU4; bottomLayer = ALU4;
317 topCLayer = CALU4; bottomCLayer = CALU4;
318 break;
319 case CONT_TURN5:
320 topLayer = ALU5; bottomLayer = ALU5;
321 topCLayer = CALU5; bottomCLayer = CALU5;
322 break;
323 case CONT_TURN6:
324 topLayer = ALU6; bottomLayer = ALU6;
325 topCLayer = CALU6; bottomCLayer = CALU6;
326 break;
327 case CONT_TURN7:
328 topLayer = ALU7; bottomLayer = ALU7;
329 topCLayer = CALU7; bottomCLayer = CALU7;
330 break;
331 case CONT_TURN8:
332 topLayer = ALU8; bottomLayer = ALU8;
333 topCLayer = CALU8; bottomCLayer = CALU8;
334 break;
335 case CONT_TURN9:
336 topLayer = ALU9; bottomLayer = ALU9;
337 topCLayer = CALU9; bottomCLayer = CALU9;
338 break;
339 default:
340 errMBK ("getAltVIALayer");
341 eprintf ("Unknown VIA id %d.\n", (int)aVIA);
342 EXIT (1);
343 }
344
345
346 /* ALU connectivity. */
347 dualLayer = (aLayer == topLayer) ? bottomLayer :
348 ((aLayer == bottomLayer) ? topLayer : (LAST_LAYER + 1));
349
350 /* CALU connectivity. */
351 if (dualLayer == LAST_LAYER + 1) {
352 __DBG(
353 fprintf (stderr, "This is a CALU %d %d | ", (int)aVIA, (int)aLayer);
354 fprintf (stderr, "topC = %d, bottomC = %d, ", (int)topCLayer,
355 (int)bottomCLayer);
356 )
357 dualLayer = (aLayer == topCLayer) ? bottomCLayer :
358 ((aLayer == bottomCLayer) ? topCLayer : (LAST_LAYER + 1));
359 __DBG( fprintf (stderr, "Layer is now %d\n", (int)dualLayer); )
360 }
361
362 if (dualLayer == LAST_LAYER + 1) {
363 errMBK ("getAltVIALayer");
364 eprintf ("VIA id %d is not contiguous with layer id %d\n",
365 (int)aVIA, (int)aLayer);
366 EXIT (1);
367 }
368
369 return (dualLayer);
370 }
371
372
373 /* ------------------------------------------------------------------
374 * Function : "getTopVIALayer()".
375 */
376
377 extern char getTopVIALayer(aVIA)
378 char aVIA;
379 {
380 char topLayer;
381
382
383 topLayer = ALU1;
384
385 switch (aVIA) {
386 case CONT_BODY_N: topLayer = ALU1; break;
387 case CONT_BODY_P: topLayer = ALU1; break;
388 case CONT_DIF_N: topLayer = ALU1; break;
389 case CONT_DIF_P: topLayer = ALU1; break;
390 case CONT_POLY: topLayer = ALU1; break;
391 case CONT_POLY2: topLayer = ALU1; break;
392 case CONT_VIA: topLayer = ALU2; break;
393 case CONT_VIA2: topLayer = ALU3; break;
394 case CONT_VIA3: topLayer = ALU4; break;
395 case CONT_VIA4: topLayer = ALU5; break;
396 case CONT_VIA5: topLayer = ALU6; break;
397 case CONT_VIA6: topLayer = ALU7; break;
398 case CONT_VIA7: topLayer = ALU8; break;
399 case CONT_VIA8: topLayer = ALU9; break;
400 case CONT_TURN1: topLayer = ALU1; break;
401 case CONT_TURN2: topLayer = ALU2; break;
402 case CONT_TURN3: topLayer = ALU3; break;
403 case CONT_TURN4: topLayer = ALU4; break;
404 case CONT_TURN5: topLayer = ALU5; break;
405 case CONT_TURN6: topLayer = ALU6; break;
406 case CONT_TURN7: topLayer = ALU7; break;
407 case CONT_TURN8: topLayer = ALU8; break;
408 case CONT_TURN9: topLayer = ALU9; break;
409 default:
410 errMBK ("getTopVIALayer");
411 eprintf ("Unknown VIA id %d.\n", (int)aVIA);
412 EXIT (1);
413 }
414
415
416 return (topLayer);
417 }
418
419
420 /* ------------------------------------------------------------------
421 * Function : "getBottomVIALayer()".
422 */
423
424 extern char getBottomVIALayer(aVIA)
425 char aVIA;
426 {
427 char bottomLayer;
428
429
430 bottomLayer = ALU1;
431
432 switch (aVIA) {
433 case CONT_BODY_N: bottomLayer = NWELL; break;
434 case CONT_BODY_P: bottomLayer = PWELL; break;
435 case CONT_DIF_N: bottomLayer = NDIF; break;
436 case CONT_DIF_P: bottomLayer = PDIF; break;
437 case CONT_POLY: bottomLayer = POLY; break;
438 case CONT_POLY2: bottomLayer = POLY2; break;
439 case CONT_VIA: bottomLayer = ALU1; break;
440 case CONT_VIA2: bottomLayer = ALU2; break;
441 case CONT_VIA3: bottomLayer = ALU3; break;
442 case CONT_VIA4: bottomLayer = ALU4; break;
443 case CONT_VIA5: bottomLayer = ALU5; break;
444 case CONT_VIA6: bottomLayer = ALU6; break;
445 case CONT_VIA7: bottomLayer = ALU7; break;
446 case CONT_VIA8: bottomLayer = ALU8; break;
447 case CONT_TURN1: bottomLayer = ALU1; break;
448 case CONT_TURN2: bottomLayer = ALU2; break;
449 case CONT_TURN3: bottomLayer = ALU3; break;
450 case CONT_TURN4: bottomLayer = ALU4; break;
451 case CONT_TURN5: bottomLayer = ALU5; break;
452 case CONT_TURN6: bottomLayer = ALU6; break;
453 case CONT_TURN7: bottomLayer = ALU7; break;
454 case CONT_TURN8: bottomLayer = ALU8; break;
455 case CONT_TURN9: bottomLayer = ALU9; break;
456 default:
457 errMBK ("getBottomVIALayer");
458 eprintf ("Unknown VIA id %d.\n", (int)aVIA);
459 EXIT (1);
460 }
461
462
463 return (bottomLayer);
464 }
465
466
467 /* ------------------------------------------------------------------
468 * Function : "isVIALayer()".
469 */
470
471 extern long isVIALayer(aVIA, aLayer)
472 char aVIA;
473 char aLayer;
474 {
475 switch (aVIA) {
476 case CONT_BODY_N:
477 if (aLayer == NWELL) return (TRUE);
478 case CONT_BODY_P:
479 if (aLayer == PWELL) return (TRUE);
480 if (aLayer == ALU1) return (TRUE);
481 if (aLayer == CALU1) return (TRUE);
482 break;
483 case CONT_DIF_N:
484 if (aLayer == NDIF) return (TRUE);
485 case CONT_DIF_P:
486 if (aLayer == PDIF) return (TRUE);
487 if (aLayer == ALU1) return (TRUE);
488 if (aLayer == CALU1) return (TRUE);
489 break;
490 case CONT_POLY:
491 if (aLayer == POLY) return (TRUE);
492 if (aLayer == ALU1) return (TRUE);
493 if (aLayer == CALU1) return (TRUE);
494 break;
495 case CONT_POLY2:
496 if (aLayer == POLY2) return (TRUE);
497 if (aLayer == ALU1) return (TRUE);
498 if (aLayer == CALU1) return (TRUE);
499 break;
500 case CONT_VIA8:
501 if (aLayer == ALU9) return (TRUE);
502 if (aLayer == CALU9) return (TRUE);
503 case CONT_VIA7:
504 if (aLayer == ALU8) return (TRUE);
505 if (aLayer == CALU8) return (TRUE);
506 case CONT_VIA6:
507 if (aLayer == ALU7) return (TRUE);
508 if (aLayer == CALU7) return (TRUE);
509 case CONT_VIA5:
510 if (aLayer == ALU6) return (TRUE);
511 if (aLayer == CALU6) return (TRUE);
512 case CONT_VIA4:
513 if (aLayer == ALU5) return (TRUE);
514 if (aLayer == CALU5) return (TRUE);
515 case CONT_VIA3:
516 if (aLayer == ALU4) return (TRUE);
517 if (aLayer == CALU4) return (TRUE);
518 case CONT_VIA2:
519 if (aLayer == ALU3) return (TRUE);
520 if (aLayer == CALU3) return (TRUE);
521 case CONT_VIA:
522 if (aLayer == ALU2) return (TRUE);
523 if (aLayer == CALU2) return (TRUE);
524 if (aLayer == ALU1) return (TRUE);
525 if (aLayer == CALU1) return (TRUE);
526 break;
527 case CONT_TURN9:
528 if (aLayer == ALU9) return (TRUE);
529 if (aLayer == CALU9) return (TRUE);
530 break;
531 case CONT_TURN8:
532 if (aLayer == ALU8) return (TRUE);
533 if (aLayer == CALU8) return (TRUE);
534 break;
535 case CONT_TURN7:
536 if (aLayer == ALU7) return (TRUE);
537 if (aLayer == CALU7) return (TRUE);
538 break;
539 case CONT_TURN6:
540 if (aLayer == ALU6) return (TRUE);
541 if (aLayer == CALU6) return (TRUE);
542 break;
543 case CONT_TURN5:
544 if (aLayer == ALU5) return (TRUE);
545 if (aLayer == CALU5) return (TRUE);
546 break;
547 case CONT_TURN4:
548 if (aLayer == ALU4) return (TRUE);
549 if (aLayer == CALU4) return (TRUE);
550 break;
551 case CONT_TURN3:
552 if (aLayer == ALU3) return (TRUE);
553 if (aLayer == CALU3) return (TRUE);
554 break;
555 case CONT_TURN2:
556 if (aLayer == ALU2) return (TRUE);
557 if (aLayer == CALU2) return (TRUE);
558 break;
559 case CONT_TURN1:
560 if (aLayer == ALU1) return (TRUE);
561 if (aLayer == CALU1) return (TRUE);
562 break;
563 default:
564 errMBK ("isVIALayer");
565 eprintf ("Unknown VIA id %d.\n", (int)aVIA);
566 EXIT (1);
567 }
568
569 return (FALSE);
570 }
571
572
573 /* ------------------------------------------------------------------
574 * Function : "getUpVIALayer()".
575 */
576
577 extern long getUpVIALayer(aVIA, aLayer)
578 char aVIA;
579 char aLayer;
580 {
581 char upLayer;
582
583
584 if (!isVIALayer (aVIA, aLayer)) {
585 errMBK ("getUpVIALayer");
586 eprintf ("Layer id %d do not belong to VIA id %d.\n",
587 (int)aLayer, (int)aVIA);
588 EXIT (1);
589 }
590
591 upLayer = getUpLayer (aLayer);
592 if (!isVIALayer (aVIA, upLayer)) upLayer = aLayer;
593
594 return (upLayer);
595 }
596
597
598 /* ------------------------------------------------------------------
599 * Function : "getTurnVIA()".
600 */
601
602 extern char getTurnVIA(aLayer)
603 char aLayer;
604 {
605 char turnVIA;
606
607
608 turnVIA = CONT_TURN1;
609
610 switch (aLayer) {
611 case ALU1:
612 case CALU1: turnVIA = CONT_TURN1; break;
613 case ALU2:
614 case CALU2: turnVIA = CONT_TURN3; break;
615 case ALU3:
616 case CALU3: turnVIA = CONT_TURN4; break;
617 case ALU4:
618 case CALU4: turnVIA = CONT_TURN5; break;
619 case ALU5:
620 case CALU5: turnVIA = CONT_TURN6; break;
621 case ALU6:
622 case CALU6: turnVIA = CONT_TURN7; break;
623 case ALU7:
624 case CALU7: turnVIA = CONT_TURN8; break;
625 case ALU8:
626 case CALU8: turnVIA = CONT_TURN9; break;
627 case ALU9:
628 case CALU9: turnVIA = CONT_TURN9; break;
629 default:
630 errMBK ("getTurnVIA");
631 eprintf ("No turn VIA for layer id %d.\n", (int)aLayer);
632 EXIT (1);
633 }
634
635 return (turnVIA);
636 }
637
638
639 /* ------------------------------------------------------------------
640 * Function : "getUpLayer()".
641 */
642
643 extern char getUpLayer(aLayer)
644 char aLayer;
645 {
646 char upLayer;
647
648
649 upLayer = ALU1;
650
651 switch (aLayer) {
652 case NWELL: upLayer = ALU1; break;
653 case PWELL: upLayer = ALU1; break;
654 case NTIE: upLayer = ALU1; break;
655 case PTIE: upLayer = ALU1; break;
656 case NDIF: upLayer = ALU1; break;
657 case PDIF: upLayer = ALU1; break;
658 case NTRANS: upLayer = ALU1; break;
659 case PTRANS: upLayer = ALU1; break;
660 case POLY: upLayer = ALU1; break;
661 case ALU1: upLayer = ALU2; break;
662 case CALU1: upLayer = ALU2; break;
663 case TALU1: upLayer = ALU2; break;
664 case ALU2: upLayer = ALU3; break;
665 case CALU2: upLayer = ALU3; break;
666 case TALU2: upLayer = ALU3; break;
667 case ALU3: upLayer = ALU4; break;
668 case CALU3: upLayer = ALU4; break;
669 case TALU3: upLayer = ALU4; break;
670 case ALU4: upLayer = ALU5; break;
671 case CALU4: upLayer = ALU5; break;
672 case TALU4: upLayer = ALU5; break;
673 case ALU5: upLayer = ALU6; break;
674 case CALU5: upLayer = ALU6; break;
675 case TALU5: upLayer = ALU6; break;
676 case ALU6: upLayer = ALU7; break;
677 case CALU6: upLayer = ALU7; break;
678 case TALU6: upLayer = ALU7; break;
679 case ALU7: upLayer = ALU8; break;
680 case CALU7: upLayer = ALU8; break;
681 case TALU7: upLayer = ALU8; break;
682 case ALU8: upLayer = ALU9; break;
683 case CALU8: upLayer = ALU9; break;
684 case TALU8: upLayer = ALU9; break;
685 case ALU9: upLayer = ALU9; break;
686 case CALU9: upLayer = ALU9; break;
687 case TALU9: upLayer = ALU9; break;
688 default:
689 errMBK ("getUpLayer");
690 eprintf ("Unknown Layer id %d.\n", (int)aLayer);
691 EXIT (1);
692 }
693
694 return (upLayer);
695 }
696
697
698 /* ------------------------------------------------------------------
699 * Function : "cmpALU()".
700 */
701
702 extern long cmpALU(aLayer1, aLayer2)
703 char aLayer1, aLayer2;
704 {
705 switch(aLayer1) {
706 case ALU1:
707 switch(aLayer2) {
708 case ALU1: return(F_EQUAL_M);
709 case CALU1: return(F_EQUAL_C);
710 case TALU1: return(F_EQUAL_T);
711 }
712 break;
713
714 case ALU2:
715 switch(aLayer2) {
716 case ALU2: return(F_EQUAL_M);
717 case CALU2: return(F_EQUAL_C);
718 case TALU2: return(F_EQUAL_T);
719 }
720 break;
721
722 case ALU3:
723 switch(aLayer2) {
724 case ALU3: return(F_EQUAL_M);
725 case CALU3: return(F_EQUAL_C);
726 case TALU3: return(F_EQUAL_T);
727 }
728 break;
729
730 case ALU4:
731 switch(aLayer2) {
732 case ALU4: return(F_EQUAL_M);
733 case CALU4: return(F_EQUAL_C);
734 case TALU4: return(F_EQUAL_T);
735 }
736 break;
737
738 case ALU5:
739 switch(aLayer2) {
740 case ALU5: return(F_EQUAL_M);
741 case CALU5: return(F_EQUAL_C);
742 case TALU5: return(F_EQUAL_T);
743 }
744 break;
745
746 case ALU6:
747 switch(aLayer2) {
748 case ALU6: return(F_EQUAL_M);
749 case CALU6: return(F_EQUAL_C);
750 case TALU6: return(F_EQUAL_T);
751 }
752 break;
753 }
754
755 return(FALSE);
756 }
757
758
759 /* ------------------------------------------------------------------
760 * Function : "getALU()".
761 */
762
763 extern char getALU(aLayer)
764 char aLayer;
765 {
766 char ALU;
767
768
769 ALU = CALU1;
770
771 switch (aLayer) {
772 case CALU1:
773 case ALU1: ALU = ALU1; break;
774 case CALU2:
775 case ALU2: ALU = ALU2; break;
776 case CALU3:
777 case ALU3: ALU = ALU3; break;
778 case CALU4:
779 case ALU4: ALU = ALU4; break;
780 case CALU5:
781 case ALU5: ALU = ALU5; break;
782 case CALU6:
783 case ALU6: ALU = ALU6; break;
784 case CALU7:
785 case ALU7: ALU = ALU7; break;
786 case CALU8:
787 case ALU8: ALU = ALU8; break;
788 case CALU9:
789 case ALU9: ALU = ALU9; break;
790 default:
791 errMBK ("getALU");
792 eprintf ("No ALU for layer id %d.\n", (int)aLayer);
793 EXIT (1);
794 }
795
796
797 return (ALU);
798 }
799
800
801 /* ------------------------------------------------------------------
802 * Function : "getCALU()".
803 */
804
805 extern char getCALU(aLayer)
806 char aLayer;
807 {
808 char CALU;
809
810
811 CALU = CALU1;
812
813 switch (aLayer) {
814 case CALU1:
815 case ALU1: CALU = CALU1; break;
816 case CALU2:
817 case ALU2: CALU = CALU2; break;
818 case CALU3:
819 case ALU3: CALU = CALU3; break;
820 case CALU4:
821 case ALU4: CALU = CALU4; break;
822 case CALU5:
823 case ALU5: CALU = CALU5; break;
824 case CALU6:
825 case ALU6: CALU = CALU6; break;
826 case CALU7:
827 case ALU7: CALU = CALU7; break;
828 case CALU8:
829 case ALU8: CALU = CALU8; break;
830 case CALU9:
831 case ALU9: CALU = CALU9; break;
832 default:
833 errMBK ("getCALU");
834 eprintf ("No CALU for layer id %d.\n", (int)aLayer);
835 EXIT (1);
836 }
837
838
839 return (CALU);
840 }
841
842
843 /* ------------------------------------------------------------------
844 * Function : "isCALU()".
845 */
846
847 extern long isCALU(aLayer)
848 char aLayer;
849 {
850 long flag;
851
852
853 flag = FALSE;
854 switch (aLayer) {
855 case CALU1:
856 case CALU2:
857 case CALU3:
858 case CALU4:
859 case CALU5:
860 case CALU6:
861 case CALU7:
862 case CALU8:
863 case CALU9: flag = TRUE; break;
864 }
865
866
867 return (flag);
868 }
869
870
871 /* ------------------------------------------------------------------
872 * Function : "getTALU()".
873 */
874
875 extern char getTALU(aLayer)
876 char aLayer;
877 {
878 char TALU;
879
880
881 TALU = TALU1;
882
883 switch (aLayer) {
884 case TALU1:
885 case CALU1:
886 case ALU1: TALU = TALU1; break;
887 case TALU2:
888 case CALU2:
889 case ALU2: TALU = TALU2; break;
890 case TALU3:
891 case CALU3:
892 case ALU3: TALU = TALU3; break;
893 case TALU4:
894 case CALU4:
895 case ALU4: TALU = TALU4; break;
896 case TALU5:
897 case CALU5:
898 case ALU5: TALU = TALU5; break;
899 case TALU6:
900 case CALU6:
901 case ALU6: TALU = TALU6; break;
902 case TALU7:
903 case CALU7:
904 case ALU7: TALU = TALU7; break;
905 case TALU8:
906 case CALU8:
907 case ALU8: TALU = TALU8; break;
908 case TALU9:
909 case CALU9:
910 case ALU9: TALU = TALU9; break;
911 default:
912 errMBK ("getTALU");
913 eprintf ("No TALU for layer id %d.\n", (int)aLayer);
914 EXIT (1);
915 }
916
917
918 return (TALU);
919 }
920
921
922 /* ------------------------------------------------------------------
923 * Function : "getLayerTrackWidth()".
924 */
925
926 extern long getLayerTrackWidth(aLayer)
927 char aLayer;
928 {
929 long trackWidth;
930
931
932 trackWidth = MBKSCALE(2);
933
934 switch (aLayer) {
935 case CALU1:
936 case TALU1:
937 case ALU1: trackWidth = MBKSCALE (1); break;
938 case CALU2:
939 case TALU2:
940 case ALU2:
941 case CALU3:
942 case TALU3:
943 case ALU3:
944 case CALU4:
945 case TALU4:
946 case ALU4:
947 case CALU5:
948 case TALU5:
949 case ALU5:
950 case CALU6:
951 case TALU6:
952 case ALU6:
953 case CALU7:
954 case TALU7:
955 case ALU7:
956 case CALU8:
957 case TALU8:
958 case ALU8:
959 case CALU9:
960 case TALU9:
961 case ALU9: trackWidth = MBKSCALE (2); break;
962 default:
963 errMBK ("getLayerTrackWidth");
964 eprintf ("No minimal track width for layer id %d.\n", (int)aLayer);
965 EXIT (1);
966 }
967
968 return (trackWidth);
969 }
970
971
972 /* ------------------------------------------------------------------
973 * Function : "xyflatseg()".
974 */
975
xyflatseg(apFlatSeg,apSeg,aXINS,aYINS,aXAB1,aYAB1,aXAB2,aYAB2,aTransf)976 extern void xyflatseg(apFlatSeg, apSeg,
977 aXINS, aYINS,
978 aXAB1, aYAB1,
979 aXAB2, aYAB2,
980 aTransf)
981 struct phseg *apFlatSeg, *apSeg;
982 long aXINS, aYINS, aXAB1, aYAB1, aXAB2, aYAB2;
983 char aTransf;
984 {
985 long swap;
986
987
988 apFlatSeg->NAME = apSeg->NAME;
989 apFlatSeg->LAYER = apSeg->LAYER;
990 apFlatSeg->WIDTH = apSeg->WIDTH;
991
992
993 xyflat (&apFlatSeg->X1, &apFlatSeg->Y1,
994 apSeg->X1, apSeg->Y1,
995 aXINS, aYINS,
996 aXAB1, aYAB1,
997 aXAB2, aYAB2,
998 aTransf);
999
1000 xyflat (&apFlatSeg->X2, &apFlatSeg->Y2,
1001 apSeg->X2, apSeg->Y2,
1002 aXINS, aYINS,
1003 aXAB1, aYAB1,
1004 aXAB2, aYAB2,
1005 aTransf);
1006
1007
1008 if (apFlatSeg->X1 > apFlatSeg->X2) {
1009 swap = apFlatSeg->X1;
1010 apFlatSeg->X1 = apFlatSeg->X2;
1011 apFlatSeg->X2 = swap;
1012 }
1013
1014 if (apFlatSeg->Y1 > apFlatSeg->Y2) {
1015 swap = apFlatSeg->Y1;
1016 apFlatSeg->Y1 = apFlatSeg->Y2;
1017 apFlatSeg->Y2 = swap;
1018 }
1019
1020 if (apFlatSeg->Y1 == apFlatSeg->Y2) {
1021 if (apFlatSeg->X1 < apFlatSeg->X2) apFlatSeg->TYPE = LEFT;
1022 else apFlatSeg->TYPE = RIGHT;
1023 } else {
1024 if (apFlatSeg->Y1 < apFlatSeg->Y2) apFlatSeg->TYPE = UP;
1025 else apFlatSeg->TYPE = DOWN;
1026 }
1027 }
1028
1029
1030 /* ------------------------------------------------------------------
1031 * Function : "isPad()".
1032 */
1033
1034 extern long isPad (asCell)
1035 char *asCell;
1036 {
1037 char *i, *ext;
1038
1039 ext = NULL;
1040 for(i = asCell; *i != (char)0; i++)
1041 if (*i == '_') ext = i;
1042
1043 if (ext == NULL) return (FALSE);
1044 if (strcmp (ext, "_sp")) return (FALSE);
1045
1046 return (TRUE);
1047 }
1048
1049
1050 /* ------------------------------------------------------------------
1051 * Function : "initSigIndex()".
1052 */
1053
1054 extern long initSigIndex(apLoSig)
1055 losig_list *apLoSig;
1056 {
1057 losig_list *pLoSig;
1058 long iMax;
1059
1060 iMax = 0L;
1061 for(pLoSig = apLoSig; pLoSig != (losig_list*)NULL; pLoSig = pLoSig->NEXT)
1062 if (pLoSig->INDEX > iMax) iMax = pLoSig->INDEX;
1063
1064 return(MBK_sigIndex = iMax);
1065 }
1066
1067
1068 /* ------------------------------------------------------------------
1069 * Function : "cmpSigName()".
1070 */
1071
1072 extern long cmpSigName(apLoSig, asName)
1073 losig_list *apLoSig;
1074 char *asName;
1075 {
1076 chain_list *pChain;
1077
1078
1079 for(pChain = apLoSig->NAMECHAIN;
1080 pChain != (chain_list*)NULL;
1081 pChain = pChain->NEXT) {
1082 if ((char*)(pChain->DATA) == asName) return(TRUE);
1083 }
1084
1085 return(FALSE);
1086 }
1087
1088
1089 /* ------------------------------------------------------------------
1090 * Function : "addInsLoCon()".
1091 */
1092
addInsLoCon(apIns,asName,apSig,aDir)1093 extern struct locon *addInsLoCon(apIns, asName, apSig, aDir)
1094 struct loins *apIns;
1095 char *asName;
1096 struct losig *apSig;
1097 char aDir;
1098 {
1099 locon_list *pCon;
1100 char *sName;
1101
1102
1103 sName = namealloc(asName);
1104 for(pCon = apIns->LOCON; pCon != (locon_list*)NULL; pCon = pCon->NEXT) {
1105 if (pCon->NAME == sName) {
1106 pCon->SIG = apSig;
1107 return(pCon);
1108 }
1109 }
1110
1111 pCon = (locon_list*)malloc(sizeof(locon_list));
1112 pCon->NAME = sName;
1113 pCon->SIG = apSig;
1114 pCon->ROOT = (void*)apIns;
1115 pCon->TYPE = INTERNAL;
1116 pCon->DIRECTION = aDir;
1117
1118 pCon->NEXT = apIns->LOCON;
1119 apIns->LOCON = pCon;
1120
1121 return(pCon);
1122 }
1123
1124
1125 /* ------------------------------------------------------------------
1126 * Function : "splitPowerNet()".
1127 */
1128
1129 extern void splitPowerNet(apLoFig, asPower)
1130 lofig_list *apLoFig;
1131 char *asPower;
1132 {
1133 ptype_list *pType;
1134 chain_list *pChain;
1135 locon_list *pLoCon;
1136 loins_list *pLoIns;
1137 losig_list *pSigPower, *pSig;
1138 char *tsSig[2], *sVDD, *sVSS, *sPOW;
1139 long powerType;
1140
1141
1142 sVDD = namealloc("vdd");
1143 sVSS = namealloc("vss");
1144
1145 tsSig[C_POWER_VDD] = namealloc("vddi");
1146 tsSig[C_POWER_VSS] = namealloc("vssi");
1147
1148 powerType = C_POWER_UNKNOWN; sPOW = (char*)NULL;
1149 if (!strcmp(asPower, sVDD)) { powerType = C_POWER_VDD; sPOW = sVDD; }
1150 if (!strcmp(asPower, sVSS)) { powerType = C_POWER_VSS; sPOW = sVSS; }
1151
1152 if (powerType == C_POWER_UNKNOWN) {
1153 eprinth((char*)NULL);
1154 eprintf("\n Only \"vdd\" and \"vss\" can be splitted (%s).\n", asPower);
1155 EXIT (1);
1156 }
1157
1158
1159 pChain = addchain((chain_list*)NULL, (void*)tsSig[powerType]);
1160 pSigPower = addlosig(apLoFig, NEWSIGINDEX, pChain, INTERNAL);
1161
1162
1163 /* Find the power net to be splitted. */
1164 for(pSig = apLoFig->LOSIG; pSig != (losig_list*)NULL; pSig = pSig->NEXT)
1165 if (cmpSigName(pSig, sPOW)) break;
1166
1167 if (pSig == (losig_list*)NULL) {
1168 eprinth((char*)NULL);
1169 eprintf("\n Signal \"%s\" not found for splitting.\n", sPOW);
1170 EXIT (1);
1171 }
1172
1173 pType = getptype(pSig->USER, (long)LOFIGCHAIN);
1174 if (pType == (ptype_list*)NULL) {
1175 eprinth((char*)NULL);
1176 eprintf("\n Signal \"%s\" have no LOFIGCHAIN.\n", sPOW);
1177 EXIT (1);
1178 }
1179
1180
1181 /* Split the power between core cells and pad cells. */
1182 pChain = (chain_list*)(pType->DATA);
1183
1184 for(; pChain != (chain_list*)NULL;
1185 pChain = pChain->NEXT) {
1186 pLoCon = (locon_list*)(pChain->DATA);
1187
1188 if (pLoCon->TYPE == INTERNAL) {
1189 pLoIns = (loins_list*)(pLoCon->ROOT);
1190
1191 if (isPad(pLoIns->FIGNAME)) pLoCon->SIG = pSigPower;
1192
1193 if ( (powerType == C_POWER_VDD)
1194 && !strcmp(pLoIns->FIGNAME, "pvddi_sp")) {
1195 addInsLoCon(pLoIns, sPOW, pSig, pLoCon->DIRECTION);
1196 }
1197
1198 if ( (powerType == C_POWER_VSS)
1199 && !strcmp(pLoIns->FIGNAME, "pvssi_sp")) {
1200 addInsLoCon(pLoIns, sPOW, pSig, pLoCon->DIRECTION);
1201 }
1202 }
1203 } /* End of "pChain" loop. */
1204 }
1205
1206
1207 /* ------------------------------------------------------------------
1208 * Function : "addPowerNet()".
1209 */
1210
1211 extern void addPowerNet(apLoFig, asPower)
1212 lofig_list *apLoFig;
1213 char *asPower;
1214 {
1215 chain_list *pChain;
1216 char *sPOW;
1217
1218
1219 sPOW = namealloc(asPower);
1220
1221 pChain = addchain((chain_list*)NULL, (void*)sPOW);
1222 addlosig(apLoFig, NEWSIGINDEX, pChain, EXTERNAL);
1223 }
1224
1225
1226 /* ------------------------------------------------------------------
1227 * Function : "xyflatvia()".
1228 */
1229
xyflatvia(apFlatVIA,apVIA,aXINS,aYINS,aXAB1,aYAB1,aXAB2,aYAB2,aTransf)1230 extern void xyflatvia(apFlatVIA, apVIA,
1231 aXINS, aYINS,
1232 aXAB1, aYAB1,
1233 aXAB2, aYAB2,
1234 aTransf)
1235 struct phvia *apFlatVIA, *apVIA;
1236 long aXINS, aYINS, aXAB1, aYAB1, aXAB2, aYAB2;
1237 char aTransf;
1238 {
1239 apFlatVIA->NAME = apVIA->NAME;
1240 apFlatVIA->TYPE = apVIA->TYPE;
1241
1242 xyflat (&apFlatVIA->XVIA, &apFlatVIA->YVIA,
1243 apVIA->XVIA, apVIA->YVIA,
1244 aXINS, aYINS,
1245 aXAB1, aYAB1,
1246 aXAB2, aYAB2,
1247 aTransf);
1248
1249 switch (aTransf) {
1250 case ROT_M:
1251 case ROT_P:
1252 case SY_RM:
1253 case SY_RP:
1254 apFlatVIA->DX = apVIA->DY;
1255 apFlatVIA->DY = apVIA->DX;
1256 break;
1257 case NOSYM:
1258 case SYM_X:
1259 case SYM_Y:
1260 case SYMXY:
1261 default:
1262 apFlatVIA->DX = apVIA->DX;
1263 apFlatVIA->DY = apVIA->DY;
1264 break;
1265 }
1266 }
1267
1268
1269 /* ------------------------------------------------------------------
1270 * Function : "findphins()".
1271 */
1272
findphins(apPhfig,insName)1273 extern struct phins *findphins(apPhfig, insName)
1274 struct phfig *apPhfig;
1275 char *insName;
1276 {
1277 struct phins *pIns;
1278
1279 for (pIns = apPhfig->PHINS; pIns != NULL; pIns = pIns->NEXT)
1280 if (pIns->INSNAME == insName) return (pIns);
1281
1282 return (NULL);
1283 }
1284
1285
1286 /* ------------------------------------------------------------------
1287 * Function : "findphmodel()".
1288 */
1289
findphmodel(apPhfig,modelName)1290 extern struct phins *findphmodel(apPhfig, modelName)
1291 struct phfig *apPhfig;
1292 char *modelName;
1293 {
1294 struct phins *pIns;
1295
1296 for (pIns = apPhfig->PHINS; pIns != NULL; pIns = pIns->NEXT)
1297 if (pIns->FIGNAME == modelName) return (pIns);
1298
1299 return (NULL);
1300 }
1301
1302
1303 /* ------------------------------------------------------------------
1304 * Function : "findlocon()".
1305 */
1306
findlocon(apLofig,conName)1307 extern struct locon *findlocon(apLofig, conName)
1308 struct lofig *apLofig;
1309 char *conName;
1310 {
1311 struct locon *pCon;
1312
1313 for (pCon = apLofig->LOCON; pCon != NULL; pCon = pCon->NEXT)
1314 if (pCon->NAME == conName) return (pCon);
1315
1316 return (NULL);
1317 }
1318
1319
1320 /* ------------------------------------------------------------------
1321 * Function : "addloins_noSig()".
1322 */
1323
1324 extern loins_list *addloins_noSig(apFig, asIns, apModel)
1325 lofig_list *apFig, *apModel;
1326 char *asIns;
1327 {
1328 loins_list *pIns = NULL;
1329 locon_list *pCon = NULL;
1330 locon_list *pInsCon = NULL;
1331 chain_list *pChain;
1332 char *figName;
1333 char *insName;
1334
1335
1336 insName = namealloc (asIns);
1337 figName = apModel->NAME;
1338
1339
1340 /* Check insName unicity */
1341 if (strcmp (insName, "*") && FAST_MODE != 'Y') {
1342 for (pIns = apFig->LOINS; pIns; pIns = pIns->NEXT) {
1343 if (pIns->INSNAME == insName) {
1344 errMBK ("defloadlophig");
1345 eprintf ("\n addloins_noSig impossible, ");
1346 eprintf ("instance %s already exist in figure %s\n",
1347 insName, apFig->NAME);
1348 EXIT(1);
1349 }
1350 }
1351 }
1352
1353
1354 if (apFig->NAME == figName) {
1355 errMBK ("defloadlophig");
1356 eprintf ("\n addloins_noSig impossible for %s,", insName);
1357 eprintf ("\n instance model is the figure %s itself\n", figName);
1358 EXIT(1);
1359 }
1360
1361
1362 pIns = (loins_list *)mbkalloc (sizeof (loins_list));
1363
1364 pIns->INSNAME = insName;
1365 pIns->FIGNAME = figName;
1366 pIns->LOCON = NULL;
1367 pIns->USER = NULL;
1368 pIns->NEXT = apFig->LOINS;
1369 apFig->LOINS = pIns;
1370
1371
1372 /* Update model list */
1373 for (pChain = apFig->MODELCHAIN; pChain; pChain = pChain->NEXT)
1374 if (pChain->DATA == (void *)figName) break;
1375
1376 if (!pChain)
1377 apFig->MODELCHAIN = addchain (apFig->MODELCHAIN, (void *)figName);
1378
1379
1380 for (pCon = apModel->LOCON; pCon; pCon = pCon->NEXT) {
1381 pInsCon = (locon_list *)mbkalloc (sizeof (locon_list));
1382
1383 pInsCon->NAME = pCon->NAME;
1384 pInsCon->DIRECTION = pCon->DIRECTION;
1385 pInsCon->TYPE = 'I';
1386 /* We do not known the signals for the time beeing. */
1387 pInsCon->SIG = NULL;
1388 pInsCon->ROOT = (void *)pIns;
1389 pInsCon->USER = NULL;
1390 pInsCon->PNODE = NULL;
1391 pInsCon->NEXT = pIns->LOCON;
1392 pIns->LOCON = pInsCon;
1393 }
1394
1395 pIns->LOCON = (locon_list *)reverse((chain_list *)pIns->LOCON);
1396
1397
1398 return (pIns);
1399 }
1400
1401
1402 /* ------------------------------------------------------------------
1403 * Function : "addlosig_insCon()".
1404 */
1405
1406 extern locon_list *addlosig_insCon(apIns, asCon, apSig)
1407 loins_list *apIns;
1408 losig_list *apSig;
1409 char *asCon;
1410 {
1411 locon_list *pCon;
1412 char *sCon;
1413
1414
1415 sCon = namealloc (asCon);
1416
1417 for (pCon = apIns->LOCON; pCon != NULL; pCon = pCon->NEXT) {
1418 if (pCon->NAME == sCon) {
1419 pCon->SIG = apSig;
1420
1421 return (pCon);
1422 }
1423
1424 }
1425
1426
1427 if (!pCon) {
1428 errMBK ("defloadlophig");
1429 eprintf ("\n addlosig_insCon impossible, ");
1430 eprintf ("instance %s of model %s has no terminal %s.\n",
1431 apIns->INSNAME, apIns->FIGNAME, sCon);
1432 EXIT(1);
1433 }
1434
1435 return (pCon);
1436 }
1437
1438
1439 /* ------------------------------------------------------------------
1440 * Function : "addfeed()".
1441 */
1442
addfeed(apLofig,apPhfig)1443 extern void addfeed (apLofig, apPhfig)
1444 struct lofig *apLofig;
1445 struct phfig *apPhfig;
1446 {
1447 struct locon *pLocon;
1448 struct phins *pPhins;
1449 struct lofig *pFeedfig;
1450 struct losig *sig, *sigVDD, *sigVSS;
1451 struct chain *pSighead, **ppSigtail;
1452
1453
1454 /* Find VDD & VSS signals. */
1455 sigVDD = apLofig->LOSIG;
1456 while (sigVDD != NULL) {
1457 if (isvdd (getsigname (sigVDD))) break;
1458 sigVDD = sigVDD->NEXT;
1459 }
1460
1461 if (!sigVDD) {
1462 errMBK (NULL);
1463 eprintf ("The netlist have no VDD net.\n");
1464 EXIT (1);
1465 }
1466
1467 sigVSS = apLofig->LOSIG;
1468 while (sigVSS != NULL) {
1469 if (isvss (getsigname (sigVSS))) break;
1470 sigVSS = sigVSS->NEXT;
1471 }
1472
1473 if (!sigVSS) {
1474 errMBK (NULL);
1475 eprintf ("The netlist have no VSS net.\n");
1476 EXIT (1);
1477 }
1478
1479
1480 /* Find the feedthru instances. */
1481 for (pPhins = apPhfig->PHINS; pPhins != NULL; pPhins = pPhins->NEXT) {
1482 if (incatalogfeed (pPhins->FIGNAME)) {
1483 pFeedfig = getlofig (pPhins->FIGNAME, 'P');
1484
1485 pSighead = NULL;
1486 ppSigtail = &pSighead;
1487
1488 /* Build the signal list. */
1489 for (pLocon = pFeedfig->LOCON; pLocon != NULL; pLocon = pLocon->NEXT) {
1490 sig = NULL;
1491
1492 if (isvdd (pLocon->NAME)) sig = sigVDD;
1493 if (isvss (pLocon->NAME)) sig = sigVSS;
1494
1495 if (!sig) {
1496 errMBK (NULL);
1497 eprintf ("\n Terminal \"%s\" of feedthru model \"%s\" is not a\n",
1498 pLocon->NAME,
1499 pPhins->FIGNAME);
1500 eprintf (" power terminal!\n");
1501 EXIT (1);
1502 }
1503
1504 *ppSigtail = addchain (*ppSigtail, (void*)sig);
1505 ppSigtail = &((*ppSigtail)->NEXT);
1506 }
1507
1508 /* Add the instance. */
1509 addloins (apLofig, pPhins->INSNAME, pFeedfig, pSighead);
1510 }
1511 }
1512 }
1513
1514
1515 /* ------------------------------------------------------------------
1516 * Function : "delfeed()".
1517 */
1518
delfeed(apLofig)1519 extern void delfeed (apLofig)
1520 struct lofig *apLofig;
1521 {
1522 struct loins *pIns;
1523 struct chain *pFeedIns, *pChain;
1524
1525 pFeedIns = NULL;
1526
1527 /* Find the feedthru instances. */
1528 for (pIns = apLofig->LOINS; pIns != NULL; pIns = pIns->NEXT) {
1529 if (incatalogfeed (pIns->FIGNAME))
1530 pFeedIns = addchain (pFeedIns, (void*)pIns->INSNAME);
1531 }
1532
1533
1534 /* Remove thoses instances. */
1535 for (pChain = pFeedIns; pChain != NULL; pChain = pChain->NEXT) {
1536 delloins (apLofig, (char*)(pChain->DATA));
1537 }
1538
1539
1540 freechain (pFeedIns);
1541 }
1542
1543
1544 /* ------------------------------------------------------------------
1545 * Function : "checkLofig()".
1546 */
1547
checkLofig(apLofig)1548 extern void checkLofig(apLofig)
1549 struct lofig *apLofig;
1550 {
1551 struct loins *pIns;
1552 struct locon *pCon;
1553 long unassigned;
1554
1555
1556 unassigned = 0;
1557
1558 for (pIns = apLofig->LOINS; pIns != NULL; pIns = pIns->NEXT) {
1559 for(pCon = pIns->LOCON; pCon != NULL; pCon = pCon->NEXT) {
1560 if (!pCon->SIG) {
1561 unassigned++;
1562
1563 warnMBK ("defloadlophfig");
1564 wprintf ("Terminal %s of instance %s is not assigned.\n",
1565 pCon->NAME, pIns->INSNAME);
1566 }
1567 }
1568 }
1569
1570 if (unassigned) {
1571 errMBK ("defloadlophig");
1572 eprintf ("There is %ld terminals unassigned.\n", unassigned);
1573 EXIT (1);
1574 }
1575 }
1576
1577
1578 /* ------------------------------------------------------------------
1579 * Function : "copyUpCALU()".
1580 */
1581
copyUpCALU(apLofig,apPhfig,aExit)1582 extern void copyUpCALU(apLofig, apPhfig, aExit)
1583 struct lofig *apLofig;
1584 struct phfig *apPhfig;
1585 long aExit;
1586 {
1587 long flag;
1588 struct locon *pLocon, *pLoconIns;
1589 struct losig *pLosig;
1590 struct chain *pChain, *pChainLocon;
1591 struct loins *pLoins;
1592 struct phseg *pPhseg;
1593 struct phins *pPhins;
1594 struct phfig *pPhfigIns;
1595 char *sigName;
1596 long X1, Y1, X2, Y2;
1597
1598
1599 lofigchain (apLofig);
1600
1601
1602 for (pLocon = apLofig->LOCON; pLocon != NULL; pLocon = pLocon->NEXT) {
1603 pLosig = pLocon->SIG;
1604
1605 flag = FALSE;
1606
1607 for(pChain = pLosig->NAMECHAIN; pChain != NULL; pChain = pChain->NEXT) {
1608 sigName = (char*)pChain->DATA;
1609
1610 if (isvdd (sigName) || isvss (sigName)) continue;
1611
1612 /* Looks if the terminal already have physical segments in CALU on
1613 * the top level of the design.
1614 * This is a bit slow but I have no time for optimization.
1615 */
1616 for (pPhseg = apPhfig->PHSEG; pPhseg != NULL; pPhseg = pPhseg->NEXT) {
1617 if ( (pPhseg->NAME == sigName)
1618 && (isCALU(pPhseg->LAYER)) ) {
1619 flag = TRUE;
1620 break;
1621 }
1622 }
1623
1624
1625 if (!flag) {
1626 /* No CALU in the top level design. We have to copy up the
1627 * terminals from the instances (in fact there should be only one
1628 * instance).
1629 */
1630 flag = FALSE;
1631
1632 pChainLocon = (chain_list*)(getptype (pLosig->USER,
1633 LOFIGCHAIN)->DATA);
1634
1635 for (; pChainLocon != NULL; pChainLocon = pChainLocon->NEXT) {
1636 /* Copy only the first CALU segment to avoid separate segments
1637 * for one equi (this is not valid for lynx).
1638 */
1639 pLoconIns = (locon_list*) pChainLocon->DATA;
1640
1641 if (pLoconIns->TYPE == INTERNAL) {
1642 pLoins = (loins_list*)(pLoconIns->ROOT);
1643
1644 pPhfigIns = getphfig (pLoins->FIGNAME, 'A');
1645 pPhins = getphins (apPhfig, pLoins->INSNAME);
1646
1647 for (pPhseg = pPhfigIns->PHSEG;
1648 pPhseg != NULL; pPhseg = pPhseg->NEXT) {
1649 if ( (pPhseg->NAME == pLoconIns->NAME)
1650 && (isCALU(pPhseg->LAYER)) ) {
1651 flag = TRUE;
1652
1653 xyflat ( &X1 , &Y1 ,
1654 pPhseg->X1 , pPhseg->Y1 ,
1655 pPhins->XINS , pPhins->YINS,
1656 pPhfigIns->XAB1, pPhfigIns->YAB1,
1657 pPhfigIns->XAB2, pPhfigIns->YAB2,
1658 pPhins->TRANSF);
1659
1660 xyflat ( &X2 , &Y2 ,
1661 pPhseg->X2 , pPhseg->Y2 ,
1662 pPhins->XINS , pPhins->YINS,
1663 pPhfigIns->XAB1, pPhfigIns->YAB1,
1664 pPhfigIns->XAB2, pPhfigIns->YAB2,
1665 pPhins->TRANSF);
1666
1667 addphseg (apPhfig,
1668 pPhseg->LAYER,
1669 pPhseg->WIDTH,
1670 X1, Y1, X2, Y2,
1671 sigName
1672 );
1673 }
1674 }
1675 }
1676 } /* End of "for(pChainLocon...)". */
1677
1678 if (!flag) {
1679 if (aExit) {
1680 errMBK ("copyUpCALU");
1681 eprintf ("\n No instances CALUx for terminal \"%s\".\n",
1682 pLocon->NAME);
1683 EXIT (1);
1684 } else {
1685 warnMBK ("copyUpCALU");
1686 wprintf ("\n No instances CALUx for terminal \"%s\".\n",
1687 pLocon->NAME);
1688 }
1689 }
1690 } /* End of "for(pChain...)". */
1691 }
1692 }
1693 }
1694
1695
1696 /* ------------------------------------------------------------------
1697 * Function : "addloseg()".
1698 */
1699
addloseg(apHead,aType,apMBKobj)1700 extern struct eLoseg_s *addloseg (apHead, aType, apMBKobj)
1701 struct eLoseg_s *apHead;
1702 long aType;
1703 void *apMBKobj;
1704 {
1705 struct eLoseg_s *pLoseg;
1706 struct ptype **ppUser;
1707
1708
1709 ppUser = NULL;
1710 pLoseg = (struct eLoseg_s*)mbkalloc (sizeof (struct eLoseg_s));
1711
1712 switch (aType) {
1713 case LOSEG_VIA: ppUser = &(((struct phvia*)apMBKobj)->USER); break;
1714 case LOSEG_CON: ppUser = &(((struct phcon*)apMBKobj)->USER); break;
1715 case LOSEG_SEG:
1716 case LOSEG_SEGCON: ppUser = &(((struct phseg*)apMBKobj)->USER); break;
1717 default:
1718 wprinth ("addloseg");
1719 eprintf ("\n Bad loseg type id %ld.\n", aType);
1720 EXIT (1);
1721 }
1722
1723 *ppUser = addptype (*ppUser, PTYPE_LOSEG, (void*)pLoseg);
1724
1725 pLoseg->type = aType;
1726 pLoseg->MBKobj = apMBKobj;
1727 pLoseg->next = apHead;
1728
1729
1730 return (pLoseg);
1731 }
1732
1733
1734 /* ------------------------------------------------------------------
1735 * Function : "delloseg()".
1736 */
1737
delloseg(apLoseg)1738 extern struct eLoseg_s *delloseg (apLoseg)
1739 struct eLoseg_s *apLoseg;
1740 {
1741 struct ptype **ppUser;
1742
1743
1744 ppUser = NULL;
1745
1746 switch (apLoseg->type) {
1747 case LOSEG_VIA: ppUser = &(((struct phvia*)apLoseg->MBKobj)->USER); break;
1748 case LOSEG_CON: ppUser = &(((struct phcon*)apLoseg->MBKobj)->USER); break;
1749 case LOSEG_SEG:
1750 case LOSEG_SEGCON: ppUser = &(((struct phseg*)apLoseg->MBKobj)->USER); break;
1751 default:
1752 wprinth ("delloseg");
1753 eprintf ("\n Bad loseg type id %ld.\n", apLoseg->type);
1754 EXIT (1);
1755 }
1756
1757 *ppUser = delptype (*ppUser, PTYPE_LOSEG);
1758
1759 return (apLoseg->next);
1760 }
1761
1762
1763 /* ------------------------------------------------------------------
1764 * Function : "addtloseg()".
1765 */
1766
addtloseg(apPhfig)1767 extern struct tLoseg_s *addtloseg (apPhfig)
1768 struct phfig *apPhfig;
1769 {
1770 struct tLoseg_s *ptLoseg;
1771 int tLoseg_size;
1772
1773
1774 if (getptype (apPhfig->USER, PTYPE_TLOSEG)) {
1775 eprinth ("addtloseg");
1776 eprintf ("\n Attempt to re-create loseglist on figure \"%s\".",
1777 apPhfig->NAME);
1778 EXIT (1);
1779 }
1780
1781
1782 ptLoseg = (struct tLoseg_s*)mbkalloc (sizeof (struct tLoseg_s));
1783
1784 apPhfig->USER = addptype (apPhfig->USER, PTYPE_TLOSEG, (void*)ptLoseg);
1785
1786 tLoseg_size = sizeof (struct eLoseg_s*) * TLOSEG_SIZE;
1787
1788 ptLoseg->sigNB = 0;
1789 ptLoseg->tSize = TLOSEG_SIZE;
1790 ptLoseg->tHT = createauthtable (TLOSEG_SIZE);
1791 ptLoseg->tAccess = (long*) malloc (sizeof (long) * TLOSEG_SIZE);
1792 ptLoseg->tFlags = (long*) malloc (sizeof (long) * TLOSEG_SIZE);
1793 ptLoseg->tLoseg = (struct eLoseg_s**) malloc (tLoseg_size);
1794
1795 memset (ptLoseg->tLoseg , 0, tLoseg_size);
1796 memset (ptLoseg->tAccess, 0, sizeof(long) * TLOSEG_SIZE);
1797 memset (ptLoseg->tFlags , 0, sizeof(long) * TLOSEG_SIZE);
1798
1799 ptLoseg->tMVIA = NULL;
1800
1801
1802 return (ptLoseg);
1803 }
1804
1805
1806 /* ------------------------------------------------------------------
1807 * Function : "gettloseg()".
1808 */
1809
gettloseg(apPhfig)1810 extern struct tLoseg_s *gettloseg (apPhfig)
1811 struct phfig *apPhfig;
1812 {
1813 struct ptype *pType;
1814
1815 pType = getptype (apPhfig->USER, PTYPE_TLOSEG);
1816
1817 if (pType) return ((struct tLoseg_s*)(pType->DATA));
1818
1819 return (NULL);
1820 }
1821
1822
1823 /* ------------------------------------------------------------------
1824 * Function : "gettlosegitem()".
1825 */
1826
gettlosegitem(apTLoseg,asKey)1827 extern struct authelem *gettlosegitem (apTLoseg, asKey)
1828 struct tLoseg_s *apTLoseg;
1829 char *asKey;
1830 {
1831 struct authelem *pElem;
1832 size_t eLoseg_size;
1833 long sigIndex;
1834
1835
1836 eLoseg_size = sizeof (struct eLoseg_s*);
1837
1838 pElem = searchauthelem (apTLoseg->tHT, asKey);
1839
1840 if (!pElem) {
1841 sigIndex = apTLoseg->sigNB;
1842
1843 __DBG(
1844 fflush (stdout);
1845 fprintf (stderr, "Adding loseg \"%s\" (id %ld)\n", asKey, sigIndex);
1846 )
1847
1848 if (apTLoseg->sigNB >= apTLoseg->tSize) {
1849 apTLoseg->tSize += TLOSEG_SIZE;
1850
1851 /* Re-allocate the 'tLoseg' table. */
1852 apTLoseg->tLoseg = (struct eLoseg_s**)realloc (
1853 apTLoseg->tLoseg, eLoseg_size * apTLoseg->tSize);
1854
1855 if (!apTLoseg->tLoseg) {
1856 eprinth ("phsegchain");
1857 eprintf ("\n Not enougth memory to re-allocate \"tLoseg\".\n");
1858 EXIT (1);
1859 }
1860
1861 memset (apTLoseg->tLoseg + (apTLoseg->tSize - TLOSEG_SIZE),
1862 0, eLoseg_size * TLOSEG_SIZE);
1863
1864
1865 /* Re-allocate the 'tAccess' & 'tFlags' tables. */
1866 apTLoseg->tAccess = (long*)realloc (
1867 apTLoseg->tAccess, sizeof(long) * apTLoseg->tSize);
1868 apTLoseg->tFlags = (long*)realloc (
1869 apTLoseg->tFlags , sizeof(long) * apTLoseg->tSize);
1870
1871 if (!apTLoseg->tAccess || !apTLoseg->tFlags) {
1872 eprinth ("phsegchain");
1873 eprintf ("\n Not enougth memory to re-allocate \"tLoseg\".\n");
1874 EXIT (1);
1875 }
1876
1877 memset (apTLoseg->tAccess + (apTLoseg->tSize - TLOSEG_SIZE),
1878 0, sizeof(long) * TLOSEG_SIZE);
1879 }
1880
1881 pElem = addauthelem (apTLoseg->tHT, asKey, sigIndex);
1882
1883 apTLoseg->sigNB += 1;
1884 }
1885
1886
1887 return (pElem);
1888 }
1889
1890
1891 /* ------------------------------------------------------------------
1892 * Function : "getlosegname()".
1893 */
1894
getlosegname(apLoseg)1895 static char *getlosegname (apLoseg)
1896 struct eLoseg_s *apLoseg;
1897 {
1898 switch (apLoseg->type) {
1899 case LOSEG_SEG: return (((struct phseg*)(apLoseg->MBKobj))->NAME);
1900 case LOSEG_VIA: return (((struct phvia*)(apLoseg->MBKobj))->NAME);
1901 case LOSEG_CON: return (((struct phcon*)(apLoseg->MBKobj))->NAME);
1902 }
1903
1904
1905 return ("Invalid loseg object! This should never happens!\n");
1906 }
1907
1908
1909 /* ------------------------------------------------------------------
1910 * Function : "freeloseg()".
1911 */
1912
freeloseg(apPhfig)1913 extern void freeloseg (apPhfig)
1914 struct phfig *apPhfig;
1915 {
1916 struct phseg *pPhseg;
1917 struct ptype *pType;
1918 struct tLoseg_s *ptLoseg;
1919 struct eMVIA_s *pMVIA, *pMVIA_next;
1920
1921
1922 for (pPhseg = apPhfig->PHSEG; pPhseg != NULL; pPhseg = pPhseg->NEXT) {
1923 if ((pType = getptype (pPhseg->USER, PTYPE_LOSEG))) {
1924 mbkfree (pType->DATA);
1925 pPhseg->USER = delptype (pPhseg->USER, PTYPE_LOSEG);
1926 }
1927 }
1928
1929
1930
1931 if ((pType = getptype (apPhfig->USER, PTYPE_TLOSEG))) {
1932 ptLoseg = (struct tLoseg_s*)(pType->DATA);
1933
1934 destroyauthtable (ptLoseg->tHT);
1935 free (ptLoseg->tLoseg);
1936
1937 for (pMVIA = ptLoseg->tMVIA; pMVIA != NULL;) {
1938 pMVIA_next = pMVIA->next;
1939
1940 mbkfree (pMVIA);
1941
1942 pMVIA = pMVIA_next;
1943 }
1944
1945
1946 mbkfree (ptLoseg->tAccess);
1947 mbkfree (ptLoseg->tFlags);
1948 mbkfree (ptLoseg);
1949
1950 apPhfig->USER = delptype (apPhfig->USER, PTYPE_TLOSEG);
1951 }
1952 }
1953
1954
1955 /* ------------------------------------------------------------------
1956 * Function : "addmvia()".
1957 */
1958
addmvia(apHead,apVIA)1959 extern struct eMVIA_s *addmvia (apHead, apVIA)
1960 struct eMVIA_s *apHead;
1961 struct phvia *apVIA;
1962 {
1963 struct eMVIA_s *pMVIA;
1964
1965
1966 pMVIA = (struct eMVIA_s*)mbkalloc (sizeof (struct eMVIA_s));
1967
1968 pMVIA->type = apVIA->TYPE;
1969 pMVIA->width = apVIA->DX;
1970 pMVIA->height = apVIA->DY;
1971 pMVIA->next = apHead;
1972
1973
1974 return (pMVIA);
1975 }
1976
1977
1978 /* ------------------------------------------------------------------
1979 * Function : "getmvia()".
1980 */
1981
getmvia(apHead,apVIA)1982 extern struct eMVIA_s *getmvia (apHead, apVIA)
1983 struct eMVIA_s *apHead;
1984 struct phvia *apVIA;
1985 {
1986 struct eMVIA_s *pMVIA;
1987
1988
1989 for (pMVIA = apHead; pMVIA != NULL; pMVIA = pMVIA->next) {
1990 if ( (pMVIA->type == apVIA->TYPE)
1991 && (pMVIA->width == apVIA->DX )
1992 && (pMVIA->height == apVIA->DY ))
1993 break;
1994 }
1995
1996 return (pMVIA);
1997 }
1998
1999
2000 /* ------------------------------------------------------------------
2001 * Function : "buildtsigalias()".
2002 */
2003
buildtsigalias(apLosig)2004 static void buildtsigalias(apLosig)
2005 struct losig *apLosig;
2006 {
2007 struct losig *pLosig;
2008 struct chain *pChain;
2009 long sigNumber;
2010
2011
2012 if (LV_htSigAlias || LV_tSigAlias) {
2013 eprinth ("buildtsigalias");
2014 eprintf ("\n Attempt to re-allocate the signal alias name table.\n");
2015 EXIT (1);
2016 }
2017
2018
2019 sigNumber = 0;
2020
2021 for (pLosig = apLosig; pLosig != NULL; pLosig = pLosig->NEXT) sigNumber++;
2022
2023
2024 LV_tSigAlias = (struct sigalias_s*) mbkalloc (
2025 sigNumber * sizeof (struct sigalias_s));
2026 LV_htSigAlias = createauthtable (sigNumber);
2027
2028
2029 sigNumber = 0;
2030
2031 for (pLosig = apLosig; pLosig != NULL; pLosig = pLosig->NEXT) {
2032 LV_tSigAlias[sigNumber].name = getsigname (pLosig);
2033 LV_tSigAlias[sigNumber].flags = 0L;
2034
2035 __DBG( fprintf (stderr, " o Main signal name := \"%s\".\n",
2036 LV_tSigAlias[sigNumber].name); )
2037
2038 for (pChain = pLosig->NAMECHAIN; pChain != NULL; pChain = pChain->NEXT) {
2039 addauthelem (LV_htSigAlias, pChain->DATA, sigNumber);
2040
2041 __DBG(
2042 fprintf (stderr, " - Alias := \"%s\".\n", (char*)pChain->DATA); )
2043
2044 if (pChain != pLosig->NAMECHAIN)
2045 LV_tSigAlias[sigNumber].flags = F_HAS_SUBNET;
2046 }
2047
2048 sigNumber++;
2049 }
2050 }
2051
2052
2053 /* ------------------------------------------------------------------
2054 * Function : "freetsigalias()".
2055 */
2056
freetsigalias()2057 static void freetsigalias()
2058 {
2059 if (!LV_htSigAlias) destroyauthtable (LV_htSigAlias);
2060 if (!LV_tSigAlias) mbkfree (LV_tSigAlias);
2061
2062 LV_htSigAlias = NULL;
2063 LV_tSigAlias = NULL;
2064 }
2065
2066
2067 /* ------------------------------------------------------------------
2068 * Function : "matchsigname()".
2069 */
2070
matchsigname(aSegName)2071 static struct sigalias_s *matchsigname(aSegName)
2072 char *aSegName;
2073 {
2074 static struct sigalias_s noSigAlias;
2075 authelem *pElem;
2076 char **tSegAlias;
2077 long iSegAlias;
2078
2079
2080 tSegAlias = makesegnamelist (aSegName);
2081
2082 for (iSegAlias = 0; tSegAlias[iSegAlias] != NULL; iSegAlias++) {
2083 pElem = searchauthelem (LV_htSigAlias, tSegAlias[iSegAlias]);
2084
2085 if (pElem)
2086 return (&(LV_tSigAlias[pElem->VALUE]));
2087 }
2088
2089 /* This name doesn't match any net name (losig).
2090 * This is probably an error.
2091 */
2092 noSigAlias.name = aSegName;
2093 noSigAlias.flags = 0L;
2094
2095 return (&noSigAlias);
2096 }
2097
2098
2099 /* ------------------------------------------------------------------
2100 * Function : "phsegchain()".
2101 */
2102
phsegchain(apLofig,apPhfig)2103 extern void phsegchain(apLofig, apPhfig)
2104 struct lofig *apLofig;
2105 struct phfig *apPhfig;
2106 {
2107 struct tLoseg_s *ptLoseg;
2108 struct phseg *pPhseg;
2109 struct phvia *pPhvia;
2110 struct phcon *pPhcon;
2111 struct sigalias_s *pSigAlias;
2112 authelem *pElem;
2113
2114
2115 ptLoseg = addtloseg (apPhfig);
2116
2117
2118 /* Building alias table name. */
2119 buildtsigalias (apLofig->LOSIG);
2120
2121
2122 /* Sorting segments by names. */
2123 for (pPhseg = apPhfig->PHSEG; pPhseg != NULL; pPhseg = pPhseg->NEXT) {
2124 __DBG(
2125 fprintf (stdout, "seg (%ld,%ld) (%ld,%ld) width %ld layer id %d\n",
2126 pPhseg->X1,
2127 pPhseg->Y1,
2128 pPhseg->X2,
2129 pPhseg->Y2,
2130 pPhseg->WIDTH,
2131 (int)pPhseg->LAYER);
2132 fflush (stdout);
2133 )
2134 if (pPhseg->NAME == NULL) {
2135 eprinth ("phsegchain");
2136 eprintf ("\n Segment (%ld,%ld) (%ld,%ld) width %ld layer id %d",
2137 pPhseg->X1,
2138 pPhseg->Y1,
2139 pPhseg->X2,
2140 pPhseg->Y2,
2141 pPhseg->WIDTH,
2142 (int)pPhseg->LAYER);
2143 eprintf ("\n doesn't have a name.\n");
2144 EXIT (1);
2145 }
2146
2147 if (pPhseg->NAME[0] == (char)0) {
2148 eprinth ("phsegchain");
2149 eprintf ("\n Segment (%ld,%ld) (%ld,%ld) width %ld layer id %d",
2150 pPhseg->X1,
2151 pPhseg->Y1,
2152 pPhseg->X2,
2153 pPhseg->Y2,
2154 pPhseg->WIDTH,
2155 (int)pPhseg->LAYER);
2156 eprintf ("\n have an empty string for name.\n");
2157 EXIT (1);
2158 }
2159
2160 if (isobs (pPhseg)) continue;
2161
2162 pSigAlias = matchsigname (pPhseg->NAME);
2163
2164 pElem = gettlosegitem (ptLoseg, pSigAlias->name);
2165
2166 ptLoseg->tLoseg[pElem->VALUE] = addloseg (ptLoseg->tLoseg[pElem->VALUE],
2167 LOSEG_SEG,
2168 (void*)pPhseg);
2169 }
2170
2171
2172 /* Sorting vias by names. */
2173 for (pPhvia = apPhfig->PHVIA; pPhvia != NULL; pPhvia = pPhvia->NEXT) {
2174 if (pPhvia->NAME == NULL) {
2175 eprinth ("phsegchain");
2176 eprintf ("\n VIA (%ld,%ld) type id %d",
2177 pPhvia->XVIA,
2178 pPhvia->YVIA,
2179 (int)pPhvia->TYPE);
2180 eprintf ("\n doesn't have a name.\n");
2181 EXIT (1);
2182 }
2183
2184 if (!getmvia (ptLoseg->tMVIA, pPhvia)) {
2185 ptLoseg->tMVIA = addmvia (ptLoseg->tMVIA, pPhvia);
2186 __DBG(
2187 fflush (stdout);
2188 fprintf (stderr, "tMVIA := 0x%08lx\n", (unsigned long)ptLoseg->tMVIA);
2189 fflush (stderr);
2190 )
2191 }
2192
2193 pSigAlias = matchsigname (pPhvia->NAME);
2194
2195 pElem = gettlosegitem (ptLoseg, pSigAlias->name);
2196
2197 ptLoseg->tLoseg[pElem->VALUE] = addloseg (ptLoseg->tLoseg[pElem->VALUE],
2198 LOSEG_VIA,
2199 (void*)pPhvia);
2200
2201 __DBG(
2202 fprintf (stderr, " - New loseg := 0x%08ld\n",
2203 (unsigned long)ptLoseg->tLoseg[pElem->VALUE]);
2204 )
2205 }
2206
2207
2208 /* Sorting terminals by names. */
2209 for (pPhcon = apPhfig->PHCON; pPhcon != NULL; pPhcon = pPhcon->NEXT) {
2210 if (pPhcon->NAME == NULL) {
2211 eprinth ("phsegchain");
2212 eprintf ("\n CON (%ld,%ld) type id %d",
2213 pPhcon->XCON,
2214 pPhcon->YCON,
2215 (int)pPhseg->TYPE);
2216 eprintf ("\n doesn't have a name.\n");
2217 EXIT (1);
2218 }
2219
2220 pSigAlias = matchsigname (pPhcon->NAME);
2221
2222 pElem = gettlosegitem (ptLoseg, pSigAlias->name);
2223
2224 ptLoseg->tLoseg[pElem->VALUE] = addloseg (ptLoseg->tLoseg[pElem->VALUE],
2225 LOSEG_CON,
2226 (void*)pPhcon);
2227
2228 __DBG(
2229 fprintf (stderr, " - New loseg := 0x%08ld\n",
2230 (unsigned long)ptLoseg->tLoseg[pElem->VALUE]);
2231 )
2232 }
2233
2234
2235 freetsigalias ();
2236
2237 __DBG(
2238 fprintf (stderr, "ptLoseg := 0x%08lx\n", (unsigned long)ptLoseg);
2239 fflush (stderr);
2240 )
2241 }
2242
2243
2244 /* ------------------------------------------------------------------
2245 * Function : "getloseglist()".
2246 */
2247
getloseglist(apPhfig,aName)2248 extern struct eLoseg_s *getloseglist(apPhfig, aName)
2249 struct phfig *apPhfig;
2250 char *aName;
2251 {
2252 struct tLoseg_s *ptLoseg;
2253 struct eLoseg_s *pLoseg;
2254 struct ptype *pType;
2255 authelem *pElem;
2256
2257
2258 if (!(pType = getptype (apPhfig->USER, PTYPE_TLOSEG))) {
2259 /*
2260 * eprinth ("getloseglist");
2261 * eprintf ("\n Figure \"%s\" doesn't have a loseg list.\n",
2262 * apPhfig->NAME);
2263 * EXIT (1);
2264 */
2265 return (NULL);
2266 }
2267 ptLoseg = (struct tLoseg_s*)(pType->DATA);
2268
2269
2270 pLoseg = NULL;
2271
2272 pElem = searchauthelem (ptLoseg->tHT, aName);
2273
2274 if (pElem) {
2275 __DBG(
2276 fflush (stdout);
2277 fprintf (stderr, "getloseglist:Loseg found (id %ld)\n", pElem->VALUE);
2278 )
2279
2280 pLoseg = ptLoseg->tLoseg [pElem->VALUE];
2281 ptLoseg->tAccess[pElem->VALUE]++;
2282 }
2283
2284
2285 return (pLoseg);
2286 }
2287
2288
2289 /* ------------------------------------------------------------------
2290 * Function : "checklosegaccess()".
2291 */
2292
checklosegaccess(apPhfig)2293 extern void checklosegaccess(apPhfig)
2294 struct phfig *apPhfig;
2295 {
2296 struct tLoseg_s *ptLoseg;
2297 struct ptype *pType;
2298 long iLoseg;
2299 long flag;
2300
2301
2302 if (!(pType = getptype (apPhfig->USER, PTYPE_TLOSEG))) {
2303 /*
2304 * eprinth ("getloseglist");
2305 * eprintf ("\n Figure \"%s\" doesn't have a loseg list.\n",
2306 * apPhfig->NAME);
2307 * EXIT (1);
2308 */
2309 return;
2310 }
2311 ptLoseg = (struct tLoseg_s*)(pType->DATA);
2312
2313
2314 flag = FALSE;
2315 for (iLoseg = 0; iLoseg < ptLoseg->sigNB; iLoseg++) {
2316 if (ptLoseg->tAccess[iLoseg] == 0) {
2317 if (!flag) {
2318 /* Print the head error message. */
2319 eprinth (NULL);
2320 eprintf ("The following physical net segments are not in the");
2321 eprintf (" netlist :\n");
2322 flag = TRUE;
2323 }
2324
2325 eprintf ("- \"%s\".\n", getlosegname (ptLoseg->tLoseg[iLoseg]));
2326 }
2327 }
2328
2329
2330 if (flag) EXIT (1);
2331 }
2332
2333
2334 /* ------------------------------------------------------------------
2335 * Function : "shiftphfig()".
2336 */
2337
shiftphfig(apPhfig,DX,DY)2338 extern void shiftphfig(apPhfig, DX, DY)
2339 struct phfig *apPhfig;
2340 long DX, DY;
2341 {
2342 struct phseg *pSeg;
2343 struct phins *pIns;
2344 struct phvia *pVIA;
2345 struct phref *pRef;
2346 struct phcon *pCon;
2347
2348
2349 apPhfig->XAB1 -= DX;
2350 apPhfig->XAB2 -= DX;
2351 apPhfig->YAB1 -= DY;
2352 apPhfig->YAB2 -= DY;
2353
2354
2355 for (pSeg = apPhfig->PHSEG; pSeg != NULL; pSeg = pSeg->NEXT) {
2356 pSeg->X1 -= DX;
2357 pSeg->X2 -= DX;
2358 pSeg->Y1 -= DY;
2359 pSeg->Y2 -= DY;
2360 }
2361
2362 for (pIns = apPhfig->PHINS; pIns != NULL; pIns = pIns->NEXT) {
2363 pIns->XINS -= DX;
2364 pIns->YINS -= DY;
2365 }
2366
2367 for (pVIA = apPhfig->PHVIA; pVIA != NULL; pVIA = pVIA->NEXT) {
2368 pVIA->XVIA -= DX;
2369 pVIA->YVIA -= DY;
2370 }
2371
2372 for (pRef = apPhfig->PHREF; pRef != NULL; pRef = pRef->NEXT) {
2373 pRef->XREF -= DX;
2374 pRef->YREF -= DY;
2375 }
2376
2377 for (pCon = apPhfig->PHCON; pCon != NULL; pCon = pCon->NEXT) {
2378 pCon->XCON -= DX;
2379 pCon->YCON -= DY;
2380 }
2381 }
2382