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