projects / tas-yagle.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Initial version of donated sources by Avertec, 3.4p5.
[tas-yagle.git] / distrib / sources / mbk / mbk_lo.c
1 /*
2 * This file is part of the Alliance CAD System
3 * Copyright (C) Laboratoire LIP6 - Département ASIM
4 * Universite Pierre et Marie Curie
5 *
6 * Home page : http://www-asim.lip6.fr/alliance/
7 * E-mail support : mailto:alliance-support@asim.lip6.fr
8 *
9 * This library is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU Library General Public License as published
11 * by the Free Software Foundation; either version 2 of the License, or (at
12 * your option) any later version.
13 *
14 * Alliance VLSI CAD System is distributed in the hope that it will be
15 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
17 * Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with the GNU C Library; see the file COPYING. If not, write to the Free
21 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 /*
25 * Purpose : acces functions to logical structures
26 * Date : 30/04/91
27 * Author : Frederic Petrot <Frederic.Petrot@lip6.fr>
28 * Modified by Czo <Olivier.Sirol@lip6.fr> 1997,98
29 * Modified by <Gregoire.Avot@lip6.fr> 1997,98
30 */
31
32 #ident "$Id: mbk_lo.c,v 1.108 2009/05/20 12:22:03 fabrice Exp $"
33
34 #include <stdio.h>
35 #include <unistd.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <limits.h>
39
40 #include MUT_H
41 #include MLO_H
42 #include RCN_H
43 #include EQT_H
44 #include AVT_H
45 #include "mbk_lo.h"
46 #include "mlu_lib.h"
47
48 int NB_TAT_LOSIG = 0;
49
50 //#define MBK_TRACE_BAD_PTYPE
51
52 /*******************************************************************************
53 * global variable for netlist view *
54 *******************************************************************************/
55 lofig_list *HEAD_LOFIG; /* physical figure list head */
56 ht *HT_LOFIG = NULL ;
57 voidt *VT_MODNAMEINDEX = NULL ;
58 ht *HT_MODINDEXNAME = NULL ;
59 char *TN_MODEL_NAME = NULL ;
60 char *TP_MODEL_NAME = NULL ;
61
62
63
64 void mbk_init_NewBKSIG(NewBKSIG *bksig)
65 {
66 bksig->maxindex=-1;
67 bksig->TAB=NULL;
68 }
69
70 void mbk_free_NewBKSIG(NewBKSIG *bksig)
71 {
72 if (bksig->TAB!=NULL) FreeAdvancedTableAllocator((AdvancedTableAllocator *)bksig->TAB);
73 bksig->TAB=NULL;
74 }
75
76 losig_list *mbk_NewBKSIG_getindex(lofig_list *ptfig, int index)
77 {
78 int sigsize;
79 AdvancedTableAllocator *ata;
80
81 if (ptfig->BKSIG.TAB==NULL)
82 {
83 sigsize = getsigsize( ptfig );
84 ptfig->BKSIG.TAB=CreateAdvancedTableAllocator(sigsize, sizeof(losig_list));
85 ata=(AdvancedTableAllocator *)ptfig->BKSIG.TAB;
86 ata->init=1;
87 }
88 else ata=(AdvancedTableAllocator *)ptfig->BKSIG.TAB;
89
90 if (index>ptfig->BKSIG.maxindex) ptfig->BKSIG.maxindex=index;
91 return (losig_list *)GetAdvancedTableElem(ata, index);
92 }
93
94 /*******************************************************************************
95 * function delalllofig() *
96 *******************************************************************************/
97 void delalllofig()
98 {
99 lofig_list *lofig ;
100 lofig_list *next ;
101
102 for( lofig = HEAD_LOFIG ; lofig ; lofig = next ) {
103 next = lofig->NEXT;
104 dellofig( lofig->NAME );
105 }
106 }
107
108 /*******************************************************************************
109 * function addlofig() *
110 *******************************************************************************/
111 lofig_list *addlofig(name)
112 char *name;
113 {
114 lofig_list *ptfig;
115
116 if (HT_LOFIG == NULL) {
117 HT_LOFIG = addht(50);
118 }
119 name = namealloc(name);
120 /* scan figure list */
121 ptfig = (lofig_list *)gethtitem(HT_LOFIG, name);
122 if (ptfig == (lofig_list *)EMPTYHT) ptfig = NULL;
123 else if (ptfig == (lofig_list *)DELETEHT) {
124 ptfig = HEAD_LOFIG;
125 while (ptfig != NULL && ptfig->NAME != name)
126 ptfig = ptfig->NEXT;
127 }
128
129 if (ptfig != NULL) /* figure exists */
130 avt_errmsg (MBK_ERRMSG, "020", AVT_FATAL, name);
131
132 ptfig = (lofig_list *)mbkalloc(sizeof(lofig_list));
133 ptfig->MODE = 'A';
134 ptfig->NAME = name;
135 ptfig->MODELCHAIN = NULL;
136 ptfig->LOINS = NULL;
137 ptfig->LOTRS = NULL;
138 ptfig->LOCON = NULL;
139 ptfig->LOSIG = NULL;
140 mbk_init_NewBKSIG(&ptfig->BKSIG);
141 ptfig->USER = NULL;
142 ptfig->NEXT = HEAD_LOFIG;
143 HEAD_LOFIG = ptfig;
144
145 if (TRACE_MODE == 'Y')
146 (void)fprintf(stdout, "--- mbk --- addlofig : %s\n", name);
147
148 addhtitem(HT_LOFIG, name, (long)ptfig);
149 return ptfig;
150 }
151
152 /*******************************************************************************
153 * function addlomodel() *
154 * used by the parsers to construct a temporary model *
155 *******************************************************************************/
156 lofig_list *addlomodel(model, name)
157 lofig_list *model;
158 char *name;
159 {
160 lofig_list *fig;
161
162 name = namealloc(name);
163 /* check to see if the model has already been loaded */
164 if(FAST_MODE != 'Y') {
165 for (fig = model; fig && fig->NAME != name; fig = fig->NEXT);
166
167 if (fig) /* figure exists */
168 avt_errmsg (MBK_ERRMSG, "021", AVT_FATAL, name);
169
170 }
171 fig = (lofig_list *)mbkalloc(sizeof(lofig_list));
172 fig->MODE = 'A';
173 fig->NAME = name;
174 fig->MODELCHAIN = NULL;
175 fig->LOINS = NULL;
176 fig->LOTRS = NULL;
177 fig->LOCON = NULL;
178 fig->LOSIG = NULL;
179 mbk_init_NewBKSIG(&fig->BKSIG);
180 fig->USER = NULL;
181 fig->NEXT = model;
182 model = fig;
183
184 if (TRACE_MODE == 'Y')
185 (void)fprintf(stdout, "--- mbk --- addlomodel : %s\n", name);
186
187 return model;
188 }
189
190 /*******************************************************************************
191 * function getloadedlofig() *
192 *******************************************************************************/
193 lofig_list *getloadedlofig(figname)
194 char *figname;
195 {
196 lofig_list *ptfig;
197
198 figname = namealloc(figname);
199 if (HT_LOFIG == NULL) {
200 HT_LOFIG = addht(50);
201 }
202
203 /* scan figure list */
204 ptfig = (lofig_list *)gethtitem(HT_LOFIG, figname);
205 if (ptfig == (lofig_list *)EMPTYHT) ptfig = NULL;
206 else if (ptfig == (lofig_list *)DELETEHT) {
207 ptfig = HEAD_LOFIG;
208 while (ptfig != NULL && ptfig->NAME != figname)
209 ptfig = ptfig->NEXT;
210 }
211 return ptfig;
212 }
213
214 /*******************************************************************************
215 * function addlofigparam() *
216 *******************************************************************************/
217 void
218 addlofigparam(lofig_list *ptlofig, char *param, float value, char *expr)
219 {
220 optparam_list *newparam;
221 ptype_list *ptuser;
222
223 ptuser = getptype(ptlofig->USER, OPT_PARAMS);
224 if (ptuser == NULL) {
225 newparam = addoptparam(NULL, param, value, expr);
226 ptlofig->USER = addptype(ptlofig->USER, OPT_PARAMS, newparam);
227 }
228 else {
229 newparam = addoptparam((optparam_list *)ptuser->DATA, param, value, expr);
230 ptuser->DATA = newparam;
231 }
232 }
233
234 /*******************************************************************************
235 * function getlofigparam() *
236 *******************************************************************************/
237 float
238 getlofigparam(lofig_list *ptlofig, void *param, char **expr, int *status)
239 {
240 ptype_list *ptuser;
241
242 ptuser = getptype(ptlofig->USER, OPT_PARAMS);
243 if (ptuser != NULL) {
244 return getoptparam((optparam_list *)ptuser->DATA, param, expr, status);
245 }
246
247 if (expr) *expr = NULL;
248 if (status) *status = 0;
249 return 0.0;
250 }
251
252 /*******************************************************************************
253 * function freelofigparams() *
254 *******************************************************************************/
255 void
256 freelofigparams(lofig_list *ptlofig)
257 {
258 ptype_list *ptuser;
259
260 ptuser = getptype(ptlofig->USER, OPT_PARAMS);
261 if (ptuser != NULL) {
262 freeoptparams((optparam_list *)ptuser->DATA);
263 ptlofig->USER = delptype(ptlofig->USER, OPT_PARAMS);
264 }
265 }
266
267 /*******************************************************************************
268 * function addlotrs() *
269 *******************************************************************************/
270 lotrs_list *addlotrs(ptfig, type, x, y, width, length, ps, pd, xs, xd, ptgrid,
271 ptsource, ptdrain, ptbulk, name)
272 lofig_list *ptfig;
273 char type;
274 long x, y;
275 long width, length, ps, pd, xs, xd;
276 losig_list *ptgrid, *ptsource, *ptdrain, *ptbulk;
277 char *name;
278 {
279 lotrs_list *pttrs;
280 locon_list *ptcon;
281
282 if (name!=NULL) name = namealloc( name );
283
284 if (!MLO_IS_TRANSN(type) && !MLO_IS_TRANSP(type))
285 avt_errmsg (MBK_ERRMSG, "022", AVT_FATAL, (long)type);
286
287 pttrs = (lotrs_list *)mbkalloc(sizeof(lotrs_list));
288 pttrs->X = x;
289 pttrs->Y = y;
290 pttrs->WIDTH = width;
291 pttrs->LENGTH = length;
292 pttrs->MODINDEX = EMPTYHT ;
293 pttrs->PS = ps;
294 pttrs->PD = pd;
295 pttrs->XS = xs;
296 pttrs->XD = xd;
297 pttrs->TYPE = type;
298 pttrs->NEXT = ptfig->LOTRS;
299 ptfig->LOTRS = pttrs;
300 pttrs->USER = NULL;
301
302 ptcon = (locon_list *)mbkalloc(sizeof(locon_list));
303 ptcon->NAME = namealloc("grid");
304 ptcon->SIG = ptgrid;
305 ptcon->ROOT = (void *)pttrs;
306 ptcon->TYPE = 'T';
307 ptcon->DIRECTION = 'I';
308 ptcon->USER = NULL;
309 ptcon->PNODE = NULL;
310 pttrs->GRID = ptcon;
311
312 ptcon = (locon_list *)mbkalloc(sizeof(locon_list));
313 ptcon->NAME = namealloc("drain");
314 ptcon->SIG = ptdrain;
315 ptcon->ROOT = (void *)pttrs;
316 ptcon->TYPE = 'T';
317 ptcon->DIRECTION = 'I';
318 ptcon->USER = NULL;
319 ptcon->PNODE = NULL;
320 pttrs->DRAIN = ptcon;
321
322 ptcon = (locon_list *)mbkalloc(sizeof(locon_list));
323 ptcon->NAME = namealloc("source");
324 ptcon->SIG = ptsource;
325 ptcon->ROOT = (void *)pttrs;
326 ptcon->TYPE = 'T';
327 ptcon->DIRECTION = 'I';
328 ptcon->USER = NULL;
329 ptcon->PNODE = NULL;
330 pttrs->SOURCE = ptcon;
331
332 ptcon = (locon_list *)mbkalloc(sizeof(locon_list));
333 ptcon->NAME = namealloc("bulk");
334 ptcon->SIG = ptbulk;
335 ptcon->ROOT = (void *)pttrs;
336 ptcon->TYPE = 'T';
337 ptcon->DIRECTION = 'I';
338 ptcon->USER = NULL;
339 ptcon->PNODE = NULL;
340 pttrs->BULK = ptcon;
341
342 /* No check is done for transistor name */
343 pttrs->TRNAME = name;
344
345 if ((TRACE_MODE == 'Y'))
346 (void)fprintf(stdout,
347 "--- mbk --- addlotrs : %s X=%ld, Y=%ld, W=%ld, L=%ld, PS = %ld, PD = %ld, XS = %ld, XD = %ld\n",
348 MLO_IS_TRANSN(type) ? "TRANSN" : "TRANSP", x, y, width, length,
349 ps, pd, xs, xd);
350
351 return pttrs;
352 }
353
354 /*******************************************************************************
355 * function addlotrsparam() *
356 *******************************************************************************/
357 void
358 addlotrsparam(lotrs_list *ptlotrs, char *param, float value, char *expr)
359 {
360 optparam_list *newparam;
361 ptype_list *ptuser;
362
363 newparam = makelotrsparam(NULL, param, value, expr);
364
365 ptuser = getptype(ptlotrs->USER, OPT_PARAMS);
366 if (ptuser == NULL) {
367 ptlotrs->USER = addptype(ptlotrs->USER, OPT_PARAMS, newparam);
368 }
369 else {
370 newparam->NEXT = ptuser->DATA;
371 ptuser->DATA = newparam;
372 }
373 }
374
375 /*******************************************************************************
376 * function makelotrsparam() *
377 *******************************************************************************/
378
379 optparam_list *
380 makelotrsparam(optparam_list *ptheadparam, char *param, float value, char *expr)
381 {
382 optparam_list *newparam;
383 char **known;
384 char buf[256];
385
386 newparam = (optparam_list *)mbkalloc(sizeof(optparam_list));
387 newparam->TAG = ' ' ;
388 newparam->NEXT = ptheadparam;
389 if ((known = getknowntrsparam(param)) != NULL) {
390 if (expr != NULL) known++;
391 newparam->UNAME.STANDARD = known;
392 }
393 else {
394 newparam->TAG=expr?'$':' ';
395
396 downstr(param, buf);
397
398 newparam->UNAME.SPECIAL = namealloc(buf);
399 }
400 if (expr) newparam->UDATA.EXPR = expr;
401 else newparam->UDATA.VALUE = value;
402
403 newparam->EQT_EXPR=NULL;
404 return newparam;
405 }
406
407 /*******************************************************************************
408 * function getlotrsparam() *
409 *******************************************************************************/
410 float
411 getlotrsparam(lotrs_list *ptlotrs, void *param, char **expr, int *status)
412 {
413 char buf[256];
414 ptype_list *ptuser;
415 optparam_list *ptparamlist;
416 char **testknown;
417 char *testunknown;
418
419
420 ptuser = getptype(ptlotrs->USER, OPT_PARAMS);
421 if (ptuser != NULL) {
422 if (isknowntrsparam(param)) {
423 testknown = param;
424 for (ptparamlist = (optparam_list *)ptuser->DATA; ptparamlist; ptparamlist = ptparamlist->NEXT) {
425 if (ptparamlist->UNAME.STANDARD == testknown) {
426 if (expr) *expr = NULL;
427 if (status) *status = 1;
428 return ptparamlist->UDATA.VALUE;
429 }
430 else if (ptparamlist->UNAME.STANDARD == testknown+1) {
431 if (expr) *expr = ptparamlist->UDATA.EXPR;
432 if (status) *status = 2;
433 return 0.0;
434 }
435 }
436 }
437 else {
438 downstr((char *)param, buf);
439 testunknown = namealloc(buf);
440 for (ptparamlist = (optparam_list *)ptuser->DATA; ptparamlist; ptparamlist = ptparamlist->NEXT) {
441 if (ptparamlist->TAG==' ' && ptparamlist->UNAME.SPECIAL == testunknown) {
442 if (expr) *expr = NULL;
443 if (status) *status = 1;
444 return ptparamlist->UDATA.VALUE;
445 }
446 else if (ptparamlist->TAG=='$' && ptparamlist->UNAME.SPECIAL == testunknown) {
447 if (expr) *expr = ptparamlist->UDATA.EXPR;
448 if (status) *status = 2;
449 return 0.0;
450 }
451 }
452 }
453
454 }
455
456 if (expr) *expr = NULL;
457 if (status) *status = 0;
458 return 0.0;
459 }
460
461 /*******************************************************************************
462 * function freelotrsparams() *
463 *******************************************************************************/
464 void
465 freelotrsparams(lotrs_list *ptlotrs)
466 {
467 optparam_list *ptparam;
468 optparam_list *ptnextparam;
469 ptype_list *ptuser;
470
471 ptuser = getptype(ptlotrs->USER, OPT_PARAMS);
472 if (ptuser != NULL) {
473 freeoptparams(ptuser->DATA);
474 /*
475 for (ptparam = (optparam_list *)ptuser->DATA; ptparam; ptparam = ptnextparam) {
476 ptnextparam = ptparam->NEXT;
477 mbkfree(ptparam);
478 }*/
479 ptlotrs->USER = delptype(ptlotrs->USER, OPT_PARAMS);
480 }
481 }
482
483 /*******************************************************************************
484 * function addlotrsmodel() *
485 *******************************************************************************/
486 short addlotrsmodel(lotrs,model)
487 lotrs_list *lotrs ;
488 char *model ;
489 {
490 char *pt ;
491 short index ;
492
493 if(VT_MODNAMEINDEX == NULL)
494 VT_MODNAMEINDEX = addvt(10) ;
495 if(HT_MODINDEXNAME == NULL)
496 HT_MODINDEXNAME = addht(10) ;
497
498 pt = namealloc(model) ;
499 index = (short )gethtitem(HT_MODINDEXNAME,pt) ;
500
501 if((index == (short)EMPTYHT) || (index == (short)DELETEHT))
502 {
503 index = (short)addvtitem(VT_MODNAMEINDEX,pt) ;
504 addhtitem(HT_MODINDEXNAME,pt,(long)index) ;
505 }
506 if (lotrs) lotrs->MODINDEX = index ;
507 return index;
508 }
509
510 /*******************************************************************************
511 * function getlotrsmodel() *
512 *******************************************************************************/
513 char *getlotrsmodel(lotrs)
514 lotrs_list *lotrs ;
515 {
516 if((VT_MODNAMEINDEX == NULL) || (HT_MODINDEXNAME == NULL) ||
517 (lotrs->MODINDEX == EMPTYHT))
518 {
519 if(TN_MODEL_NAME == NULL)
520 TN_MODEL_NAME = namealloc("tn") ;
521
522 if(TP_MODEL_NAME == NULL)
523 TP_MODEL_NAME = namealloc("tp") ;
524
525 return((MLO_IS_TRANSN(lotrs->TYPE)) ? TN_MODEL_NAME : TP_MODEL_NAME) ;
526 }
527
528 return((char *)getvtitem(VT_MODNAMEINDEX,lotrs->MODINDEX)) ;
529 }
530
531 /*******************************************************************************
532 * function addloins() *
533 *******************************************************************************/
534 loins_list *addloins(ptfig, insname, ptnewfig, sigchain)
535 lofig_list *ptfig;
536 char *insname;
537 lofig_list *ptnewfig;
538 chain_list *sigchain;
539 {
540 locon_list *ptcon = NULL;
541 locon_list *ptnewcon = NULL;
542 loins_list *ptins = NULL;
543 char *figname;
544 chain_list *ptchain;
545
546 insname = namealloc(insname);
547 figname = ptnewfig->NAME;
548
549 /* check insname unicity */
550 if (strcmp(insname, "*") && FAST_MODE != 'Y') {
551 for (ptins = ptfig->LOINS; ptins; ptins = ptins->NEXT) {
552 if (ptins->INSNAME == insname) {
553 avt_errmsg (MBK_ERRMSG, "023", AVT_FATAL, insname, ptfig->NAME);
554 }
555 }
556 }
557
558 if (ptfig->NAME == figname)
559 avt_errmsg (MBK_ERRMSG, "024", AVT_FATAL, figname);
560
561 ptins = (loins_list *)mbkalloc(sizeof(loins_list));
562
563 ptins->INSNAME = insname;
564 ptins->FIGNAME = figname;
565 ptins->LOCON = NULL;
566 ptins->USER = NULL;
567 ptins->NEXT = ptfig->LOINS;
568 ptfig->LOINS = ptins;
569
570 /* update model list */
571 for (ptchain = ptfig->MODELCHAIN; ptchain; ptchain = ptchain->NEXT)
572 if (ptchain->DATA == (void *)figname)
573 break;
574
575 if (!ptchain)
576 ptfig->MODELCHAIN = addchain(ptfig->MODELCHAIN, (void *)figname);
577
578 for (ptcon = ptnewfig->LOCON; ptcon; ptcon = ptcon->NEXT) {
579 if (sigchain == NULL)
580 avt_errmsg (MBK_ERRMSG, "025", AVT_FATAL, ptnewfig->NAME, insname, ptfig->NAME);
581
582 ptnewcon = (locon_list *)mbkalloc(sizeof(locon_list));
583 ptnewcon->NAME = ptcon->NAME;
584 ptnewcon->DIRECTION = ptcon->DIRECTION;
585 ptnewcon->TYPE = 'I';
586 ptnewcon->SIG = (losig_list *)sigchain->DATA;
587 ptnewcon->ROOT = (void *)ptins;
588 ptnewcon->USER = NULL;
589 ptnewcon->PNODE= NULL;
590 ptnewcon->NEXT = ptins->LOCON;
591 ptins->LOCON = ptnewcon;
592 sigchain = sigchain->NEXT;
593 }
594 if (sigchain != NULL)
595 avt_errmsg (MBK_ERRMSG, "025", AVT_FATAL, ptnewfig->NAME, insname, ptfig->NAME);
596
597 ptins->LOCON = (locon_list *)reverse((chain_list *)ptins->LOCON);
598
599 if (TRACE_MODE == 'Y')
600 (void)fprintf(stdout, "--- mbk --- addloins : %s of figure %s\n",
601 insname, figname);
602 return ptins;
603 }
604
605 /*******************************************************************************
606 * function addloinsparam() *
607 *******************************************************************************/
608 void
609 addloinsparam(loins_list *ptloins, char *param, float value, char *expr)
610 {
611 optparam_list *newparam;
612 ptype_list *ptuser;
613
614 newparam = (optparam_list *)mbkalloc(sizeof(optparam_list));
615 newparam->NEXT = NULL;
616
617 newparam->TAG=expr?'$':' ';
618
619 newparam->UNAME.SPECIAL = namealloc(param);
620 if (expr) newparam->UDATA.EXPR = expr;
621 else newparam->UDATA.VALUE = value;
622 newparam->EQT_EXPR=NULL;
623 ptuser = getptype(ptloins->USER, OPT_PARAMS);
624 if (ptuser == NULL) {
625 ptloins->USER = addptype(ptloins->USER, OPT_PARAMS, newparam);
626 }
627 else {
628 newparam->NEXT = ptuser->DATA;
629 ptuser->DATA = newparam;
630 }
631 }
632
633 /*******************************************************************************
634 * function getloinsparam() *
635 *******************************************************************************/
636 float
637 getloinsparam(loins_list *ptloins, void *param, char **expr, int *status)
638 {
639 char buf[256];
640 ptype_list *ptuser;
641 optparam_list *ptparamlist;
642 char *testunknown;
643
644
645 ptuser = getptype(ptloins->USER, OPT_PARAMS);
646 if (ptuser != NULL) {
647 downstr((char *)param, buf);
648 testunknown = namealloc(buf);
649 for (ptparamlist = (optparam_list *)ptuser->DATA; ptparamlist; ptparamlist = ptparamlist->NEXT) {
650 if (ptparamlist->TAG==' ' && ptparamlist->UNAME.SPECIAL == testunknown) {
651 if (expr) *expr = NULL;
652 if (status) *status = 1;
653 return ptparamlist->UDATA.VALUE;
654 }
655 else if (ptparamlist->TAG=='$' && ptparamlist->UNAME.SPECIAL == testunknown) {
656 if (expr) *expr = ptparamlist->UDATA.EXPR;
657 if (status) *status = 2;
658 return 0.0;
659 }
660 }
661 }
662
663 if (expr) *expr = NULL;
664 if (status) *status = 0;
665 return 0.0;
666 }
667
668 /*******************************************************************************
669 * function freeloinsparams() *
670 *******************************************************************************/
671 void
672 freeloinsparams(loins_list *ptloins)
673 {
674 optparam_list *ptparam;
675 optparam_list *ptnextparam;
676 ptype_list *ptuser;
677
678 ptuser = getptype(ptloins->USER, OPT_PARAMS);
679 if (ptuser != NULL) {
680 for (ptparam = (optparam_list *)ptuser->DATA; ptparam; ptparam = ptnextparam) {
681 ptnextparam = ptparam->NEXT;
682 mbkfree(ptparam);
683 }
684 ptloins->USER = delptype(ptloins->USER, OPT_PARAMS);
685 }
686 }
687
688 /*******************************************************************************
689 * function addlocon() *
690 *******************************************************************************/
691 locon_list *addlocon(ptfig, name, ptsig, dir)
692 lofig_list *ptfig;
693 char *name;
694 losig_list *ptsig;
695 char dir;
696 {
697 locon_list *ptcon;
698
699 name = namealloc(name);
700
701 /* check name unicity */
702 if (FAST_MODE != 'Y') {
703 for (ptcon = ptfig->LOCON; ptcon; ptcon = ptcon->NEXT) {
704 if (ptcon->NAME == name) {
705 avt_errmsg (MBK_ERRMSG, "026", AVT_FATAL, name, ptfig->NAME);
706 }
707 }
708 if (dir != 'I' && dir != 'O' && dir != 'X' && dir != 'B'
709 && dir != 'Z' && dir != 'T' && dir != 'A') {
710 avt_errmsg (MBK_ERRMSG, "027", AVT_FATAL, dir, ptfig->NAME);
711 }
712 }
713
714 ptcon = (locon_list *)mbkalloc(sizeof(locon_list));
715 ptcon->NAME = name;
716 ptcon->TYPE = 'E';
717 ptcon->SIG = ptsig;
718 ptcon->ROOT = (void *)ptfig;
719 ptcon->DIRECTION = dir;
720 ptcon->USER = NULL;
721 ptcon->NEXT = ptfig->LOCON;
722 ptcon->PNODE = NULL;
723 ptfig->LOCON = ptcon;
724
725 if (TRACE_MODE == 'Y')
726 {
727 if (ptsig!=NULL)
728 (void)fprintf(stdout, "--- mbk --- addlocon : %s linked to %ld\n",
729 name, ptsig->INDEX);
730 else
731 (void)fprintf(stdout, "--- mbk --- addlocon : %s no signal\n", name);
732 }
733
734 return ptcon;
735 }
736
737 /*******************************************************************************
738 * function addlosig() *
739 *******************************************************************************/
740
741 losig_list *addlosig(ptfig, index, namechain, type)
742 lofig_list *ptfig;
743 long index;
744 chain_list *namechain;
745 char type;
746 {
747 losig_list *ptsig;
748 losig_list *pthead;
749 ptype_list *pt;
750 chain_list *ptchain;
751 /* int high;
752 int low;
753 int i;
754 int sigsize;
755
756 sigsize = getsigsize( ptfig );
757
758 low = (index % sigsize);
759 high = (index / sigsize);
760 for (pt = ptfig->BKSIG; pt; pt = pt->NEXT)
761 if (pt->TYPE == high)
762 break;
763 if (pt == NULL) {
764 pthead = (losig_list *)mbkalloc(sigsize * sizeof(losig_list));
765 ptsig = pthead;
766 for (i = 0; i < sigsize; i++) {
767 ptsig->INDEX = 0;
768 ptsig++;
769 }
770 ptfig->BKSIG = (ptype_list *)addptype(ptfig->BKSIG,
771 (long)high, (void *)pthead);
772 pt = ptfig->BKSIG;
773 }
774 ptsig = (losig_list *)(pt->DATA) + low;*/
775
776 ptsig = mbk_NewBKSIG_getindex(ptfig, index);
777
778 /* check index unicity */
779 if (ptsig->INDEX != 0L) {
780 avt_errmsg (MBK_ERRMSG, "028", AVT_FATAL, index, ptfig->NAME);
781 }
782 for (ptchain = namechain; ptchain; ptchain = ptchain->NEXT)
783 ptchain->DATA = (void *)namealloc((char *)ptchain->DATA);
784
785 ptsig->NAMECHAIN = namechain;
786 ptsig->INDEX = index;
787 ptsig->USER = NULL;
788 ptsig->PRCN = NULL;
789 ptsig->TYPE = type;
790 ptsig->NEXT = ptfig->LOSIG;
791 ptfig->LOSIG = ptsig;
792 ptsig->RCNCACHE = 0;
793 ptsig->ALIMFLAGS = 0;
794
795 if (TRACE_MODE == 'Y') {
796 (void)fprintf(stdout, "--- mbk --- addlosig : %ld ", index);
797 if (ptsig->NAMECHAIN)
798 if (ptsig->NAMECHAIN->DATA)
799 (void)fprintf(stdout, "name : %s",
800 (char *)((chain_list *)(ptsig->NAMECHAIN))->DATA);
801 (void)fprintf(stdout, "\n");
802 }
803
804 return ptsig;
805 }
806
807 /*******************************************************************************
808 * function dellofig() *
809 *******************************************************************************/
810 int dellofig(char *name)
811 {
812 void *ptold=NULL;
813 lofig_list *ptfig;
814 int ret;
815
816 name = namealloc(name);
817 for (ptfig = HEAD_LOFIG; ptfig; ptfig = ptfig->NEXT) {
818 if (ptfig->NAME == name)
819 break;
820 ptold = (void *)ptfig;
821 }
822
823 if (ptfig == NULL || islofiglocked(ptfig) )
824 return 0;
825
826 if (ptfig == HEAD_LOFIG)
827 HEAD_LOFIG = ptfig->NEXT;
828 else
829 ((lofig_list *)ptold)->NEXT = ptfig->NEXT;
830 delhtitem(HT_LOFIG, name);
831 ret=freelofig(ptfig);
832 if (ret && TRACE_MODE == 'Y')
833 (void)fprintf(stdout, "--- mbk --- dellofig : %s\n", name);
834 return ret;
835 }
836
837 int freelofig(lofig_list *ptfig)
838 {
839 losig_list *ptsig;
840 loins_list *ptins;
841 locon_list *ptcon;
842 lotrs_list *pttrs;
843 ptype_list *pt;
844
845 void *ptold=NULL,*ptt; /* Nom sponsorise par France Telecon */
846
847
848 if( ptfig && islofiglocked(ptfig) )
849 return( 0 );
850
851 mbk_freeparallel(ptfig);
852
853 rcn_disable_cache( ptfig );
854
855 freectclist( ptfig, NULL );
856 for (ptsig = ptfig->LOSIG; ptsig; ptsig = ptsig->NEXT)
857 {
858 freechain(ptsig->NAMECHAIN);
859 if(ptsig->PRCN)
860 freelorcnet(ptsig);
861 dellosiguser( ptsig );
862 }
863
864 for (ptins = ptfig->LOINS; ptins; ptins = (loins_list *)ptold) {
865 freeloinsparams (ptins);
866 delloinsuser( ptins );
867 for (ptcon = ptins->LOCON; ptcon; ptcon = (locon_list *)ptt) {
868 ptt = (void *)ptcon->NEXT;
869 delloconuser( ptcon );
870 mbkfree((void *)ptcon);
871 }
872 ptold = (void *)ptins->NEXT;
873 mbkfree((void *)ptins);
874 }
875
876 mbk_free_NewBKSIG(&ptfig->BKSIG);
877 /* for (pt = ptfig->BKSIG; pt; pt = pt->NEXT) {
878 mbkfree((void *)pt->DATA);
879 }
880 freeptype(ptfig->BKSIG);*/
881 for (ptcon = ptfig->LOCON; ptcon; ptcon = (locon_list *)ptold) {
882 ptold = (void *)ptcon->NEXT;
883 delloconuser( ptcon );
884 mbkfree((void *)ptcon);
885 }
886
887
888 for (pttrs = ptfig->LOTRS; pttrs; pttrs = (lotrs_list *)ptold) {
889 delloconuser( pttrs->GRID );
890 delloconuser( pttrs->SOURCE );
891 delloconuser( pttrs->DRAIN );
892 if (pttrs->BULK!=NULL)
893 {
894 delloconuser( pttrs->BULK );
895 mbkfree((void *)pttrs->BULK);
896 }
897
898 mbkfree((void *)pttrs->GRID);
899 mbkfree((void *)pttrs->SOURCE);
900 mbkfree((void *)pttrs->DRAIN);
901 // mbkfree((void *)pttrs->BULK);
902 ptold = (void *)pttrs->NEXT;
903 freelotrsparams (pttrs);
904 dellotrsuser( pttrs );
905 mbkfree((void *)pttrs);
906 }
907 dellofiguser( ptfig );
908 freechain(ptfig->MODELCHAIN);
909 mbkfree((void *)ptfig);
910 return 1;
911 }
912
913 /*******************************************************************************
914 * function freelomodel() *
915 *******************************************************************************/
916 void freelomodel(ptmodel)
917 lofig_list *ptmodel;
918 {
919 lofig_list *ptfig;
920 locon_list *ptcon;
921 locon_list *ptc;
922
923 if (!ptmodel) /* nothing to be freed */
924 return;
925
926 ptfig = ptmodel->NEXT;
927 while (1) {
928 for (ptcon = ptmodel->LOCON; ptcon; ptcon = ptc) {
929 ptc = ptcon->NEXT;
930 mbkfree((void *)ptcon);
931 }
932 mbkfree((void *)ptmodel);
933 ptmodel = ptfig;
934 if (!ptfig)
935 break;
936 ptfig = ptfig->NEXT;
937 }
938
939 if (TRACE_MODE == 'Y')
940 (void)fprintf(stdout, "--- mbk --- freelomodel\n");
941 }
942
943 /*******************************************************************************
944 * function dellosig() *
945 *******************************************************************************/
946 int dellosig(ptfig, index)
947 lofig_list *ptfig;
948 long index;
949 {
950 losig_list *ptsav=NULL;
951 losig_list *ptsig;
952
953 for (ptsig = ptfig->LOSIG; ptsig; ptsig = ptsig->NEXT) {
954 if (ptsig->INDEX == index)
955 break;
956 ptsav = ptsig;
957 }
958
959 if (ptsig == NULL)
960 return 0;
961 else if (ptsig == ptfig->LOSIG)
962 ptfig->LOSIG = ptsig->NEXT;
963 else
964 ptsav->NEXT = ptsig->NEXT;
965
966 if( ptsig->PRCN )
967 freelorcnet( ptsig );
968 ptsig->INDEX = 0L;
969
970 freechain(ptsig->NAMECHAIN);
971 ptsig->NAMECHAIN=NULL;
972
973 dellosiguser( ptsig );
974
975 if (TRACE_MODE == 'Y')
976 (void)fprintf(stdout, "--- mbk --- dellosig : %ld\n", index);
977
978 return 1;
979 }
980
981 /*******************************************************************************
982 * function dellotrs() *
983 *******************************************************************************/
984 int dellotrs(ptfig, pttrs)
985 lofig_list *ptfig;
986 lotrs_list *pttrs;
987 {
988 lotrs_list *pt;
989 lotrs_list *ptsav=NULL;
990
991 for (pt = ptfig->LOTRS; pt; pt = pt->NEXT) {
992 if (pt == pttrs)
993 break;
994 ptsav = pt;
995 }
996 if (pt == NULL)
997 return 0;
998 else if (pt == ptfig->LOTRS)
999 ptfig->LOTRS = pt->NEXT;
1000 else
1001 ptsav->NEXT = pt->NEXT;
1002
1003 if( pt->GRID->PNODE )
1004 delrcnlocon( pt->GRID );
1005 delloconuser( pt->GRID );
1006 mbkfree((void *)pt->GRID);
1007
1008 if( pt->SOURCE->PNODE )
1009 delrcnlocon( pt->SOURCE );
1010 delloconuser( pt->SOURCE );
1011 mbkfree((void *)pt->SOURCE);
1012
1013 if( pt->DRAIN->PNODE )
1014 delrcnlocon( pt->DRAIN );
1015 delloconuser( pt->DRAIN );
1016 mbkfree((void *)pt->DRAIN);
1017
1018 if (pt->BULK!=NULL)
1019 {
1020 if( pt->BULK->PNODE )
1021 delrcnlocon( pt->BULK );
1022 delloconuser( pt->BULK );
1023 mbkfree((void *)pt->BULK);
1024 }
1025
1026 freelotrsparams(pt);
1027 dellotrsuser( pt );
1028 mbkfree((void *)pt);
1029 if (TRACE_MODE == 'Y')
1030 (void)fprintf(stdout, "--- mbk --- dellotrs : \n");
1031 return 1;
1032 }
1033
1034 int delflaggedlotrs(ptfig, flagname)
1035 lofig_list *ptfig;
1036 char *flagname;
1037 {
1038 lotrs_list *pt, *next;
1039 lotrs_list *ptsav=NULL;
1040
1041 for (pt = ptfig->LOTRS; pt; pt = next) {
1042 next=pt->NEXT;
1043 if (pt->TRNAME==flagname)
1044 {
1045 if (ptsav == NULL) ptfig->LOTRS = pt->NEXT;
1046 else ptsav->NEXT = pt->NEXT;
1047
1048 if( pt->GRID->PNODE )
1049 delrcnlocon( pt->GRID );
1050 delloconuser( pt->GRID );
1051 mbkfree((void *)pt->GRID);
1052
1053 if( pt->SOURCE->PNODE )
1054 delrcnlocon( pt->SOURCE );
1055 delloconuser( pt->SOURCE );
1056 mbkfree((void *)pt->SOURCE);
1057
1058 if( pt->DRAIN->PNODE )
1059 delrcnlocon( pt->DRAIN );
1060 delloconuser( pt->DRAIN );
1061 mbkfree((void *)pt->DRAIN);
1062
1063 if (pt->BULK!=NULL)
1064 {
1065 if( pt->BULK->PNODE )
1066 delrcnlocon( pt->BULK );
1067 delloconuser( pt->BULK );
1068 mbkfree((void *)pt->BULK);
1069 }
1070
1071 freelotrsparams(pt);
1072 dellotrsuser( pt );
1073 mbkfree((void *)pt);
1074 }
1075 else ptsav=pt;
1076 }
1077 return 1;
1078 }
1079
1080 /*******************************************************************************
1081 * function delloins() *
1082 *******************************************************************************/
1083 int delloins(ptfig, insname)
1084 lofig_list *ptfig;
1085 char *insname;
1086 {
1087 loins_list *ptins;
1088 locon_list *ptcon;
1089 chain_list *ptchain;
1090 chain_list *pttmpchain=NULL;
1091 void *pt=NULL;
1092 char *figname;
1093
1094 insname = namealloc(insname);
1095 for (ptins = ptfig->LOINS; ptins; ptins = ptins->NEXT) {
1096 if (ptins->INSNAME == insname)
1097 break;
1098 pt = (void *)ptins;
1099 }
1100 if (ptins == NULL)
1101 return 0;
1102 if (ptins == ptfig->LOINS) {
1103 figname = ptins->FIGNAME;
1104 ptfig->LOINS = ptins->NEXT;
1105 } else {
1106 figname = ptins->FIGNAME;
1107 ((loins_list *)pt)->NEXT = ptins->NEXT;
1108 }
1109 for (ptcon = ptins->LOCON; ptcon; ptcon = (locon_list *)pt) {
1110 if( ptcon->PNODE )
1111 delrcnlocon( ptcon );
1112 pt = (void *)ptcon->NEXT;
1113 delloconuser( ptcon );
1114 mbkfree((void *)ptcon);
1115 }
1116
1117 delloinsuser( ptins );
1118 mbkfree((void *)ptins);
1119
1120 for (ptins = ptfig->LOINS; ptins; ptins = ptins->NEXT)
1121 if (ptins->FIGNAME == figname)
1122 break;
1123 if (ptins == NULL) { /* if no more instance have this model, destroy */
1124 for (ptchain = ptfig->MODELCHAIN; ptchain; ptchain = ptchain->NEXT) {
1125 if (ptchain->DATA == (void *)figname)
1126 break;
1127 pttmpchain = ptchain;
1128 }
1129 if (ptchain == ptfig->MODELCHAIN && ptchain != NULL)
1130 ptfig->MODELCHAIN = ptchain ->NEXT;
1131 else if (ptchain)
1132 pttmpchain->NEXT = ptchain->NEXT;
1133
1134 if( ptchain )
1135 {
1136 ptchain->NEXT = NULL;
1137 freechain( ptchain );
1138 }
1139 }
1140
1141 if (TRACE_MODE == 'Y')
1142 (void)fprintf(stdout, "--- mbk --- delloins : %s\n", insname);
1143 return 1;
1144 }
1145
1146 int delflaggedloins(lofig_list *ptfig)
1147 {
1148 loins_list *ptins;
1149 locon_list *ptcon, *nextlocon;
1150 chain_list *newmodelchain=NULL;
1151 loins_list *pt=NULL, *next;
1152 int cnt=0;
1153 ht *tmodel;
1154
1155 tmodel = addht(1000);
1156
1157 for (ptins = ptfig->LOINS; ptins; ptins = next)
1158 {
1159 next=ptins->NEXT;
1160 if (ptins->INSNAME == NULL)
1161 {
1162 if (pt == NULL) ptfig->LOINS = ptins->NEXT;
1163 else pt->NEXT=ptins->NEXT;
1164 for (ptcon = ptins->LOCON; ptcon; ptcon = nextlocon)
1165 {
1166 nextlocon=ptcon->NEXT;
1167 if( ptcon->PNODE ) delrcnlocon( ptcon );
1168 delloconuser( ptcon );
1169 mbkfree((void *)ptcon);
1170 }
1171 delloinsuser( ptins );
1172 freeptype(ptins->USER);
1173 if (TRACE_MODE == 'Y')
1174 (void)fprintf(stdout, "--- mbk --- delloins\n");
1175 mbkfree((void *)ptins);
1176 cnt++;
1177 }
1178 else
1179 {
1180 if( gethtitem( tmodel, ptins->FIGNAME ) == EMPTYHT ) {
1181 newmodelchain=addchain(newmodelchain, ptins->FIGNAME);
1182 addhtitem( tmodel, ptins->FIGNAME, 1l );
1183 }
1184 /*
1185 for (ptchain = newmodelchain; ptchain && ptchain->DATA!=ptins->FIGNAME; ptchain = ptchain->NEXT) ;
1186 if (ptchain==NULL) newmodelchain=addchain(newmodelchain, ptins->FIGNAME);
1187 */
1188 pt = ptins;
1189 }
1190 }
1191
1192 delht( tmodel );
1193 freechain(ptfig->MODELCHAIN);
1194 ptfig->MODELCHAIN=newmodelchain;
1195
1196 return cnt;
1197 }
1198 /*******************************************************************************
1199 * function dellocon() *
1200 *******************************************************************************/
1201 int dellocon(ptfig, name)
1202 lofig_list *ptfig;
1203 char *name;
1204 {
1205 locon_list *ptcon;
1206 locon_list *ptsav=NULL;
1207
1208 name = namealloc(name);
1209 for (ptcon = ptfig->LOCON; ptcon; ptcon = ptcon->NEXT) {
1210 if (ptcon->NAME == name)
1211 break;
1212 ptsav = ptcon;
1213 }
1214 if (ptcon == NULL)
1215 return 0;
1216 else if (ptcon == ptfig->LOCON)
1217 ptfig->LOCON = ptcon->NEXT;
1218 else
1219 ptsav->NEXT = ptcon->NEXT;
1220
1221 if( ptcon->PNODE )
1222 delrcnlocon( ptcon );
1223
1224 delloconuser( ptcon );
1225 mbkfree((void *)ptcon);
1226 if (TRACE_MODE == 'Y')
1227 (void)fprintf(stdout, "--- mbk --- dellocon : %s\n", name);
1228
1229 return 1;
1230 }
1231
1232 /*******************************************************************************
1233 * function getlomodel *
1234 * gives a pointer to a model or NULL if it doesn't exist *
1235 *******************************************************************************/
1236 lofig_list *getlomodel(ptmodel, name)
1237 lofig_list *ptmodel;
1238 char *name;
1239 {
1240 lofig_list *ptfig;
1241
1242 name = namealloc(name);
1243 for (ptfig = ptmodel; ptfig; ptfig = ptfig->NEXT)
1244 if (ptfig->NAME == name)
1245 return ptfig;
1246 return NULL;
1247 }
1248
1249 /*******************************************************************************
1250 * function getloins() *
1251 *******************************************************************************/
1252 loins_list *getloins(ptfig, name)
1253 lofig_list *ptfig;
1254 char *name;
1255 {
1256 loins_list *ptins;
1257
1258 name = namealloc(name);
1259
1260 for (ptins = ptfig->LOINS; ptins; ptins = ptins->NEXT)
1261 if (ptins->INSNAME == name)
1262 return ptins;
1263
1264 avt_errmsg (MBK_ERRMSG, "029", AVT_FATAL, name, ptfig->NAME);
1265 return NULL; /* never reached */
1266 }
1267
1268 /*******************************************************************************
1269 * function getlotrs() *
1270 *******************************************************************************/
1271 lotrs_list *getlotrs(ptfig, name)
1272 lofig_list *ptfig;
1273 char *name;
1274 {
1275 lotrs_list *pttrs;
1276
1277 name = namealloc(name);
1278
1279 for (pttrs = ptfig->LOTRS; pttrs; pttrs = pttrs->NEXT)
1280 if (pttrs->TRNAME == name)
1281 return pttrs;
1282
1283 avt_errmsg (MBK_ERRMSG, "030", AVT_FATAL, name, ptfig->NAME);
1284 return NULL; /* never reached */
1285 }
1286
1287 /*******************************************************************************
1288 * function getlocon() *
1289 *******************************************************************************/
1290 locon_list *getlocon(ptfig, name)
1291 lofig_list *ptfig;
1292 char *name;
1293 {
1294 locon_list *ptcon;
1295
1296 name = namealloc(name);
1297
1298 for (ptcon = ptfig->LOCON; ptcon; ptcon = ptcon->NEXT)
1299 if (ptcon->NAME == name)
1300 return ptcon;
1301
1302 avt_errmsg (MBK_ERRMSG, "031", AVT_FATAL, name, ptfig->NAME);
1303 return NULL; /* never reached */
1304 }
1305
1306 /*******************************************************************************
1307 * function getlosig() *
1308 *******************************************************************************/
1309 losig_list *getlosig(lofig_list *ptfig, long index)
1310 {
1311 losig_list *ptsig;
1312
1313 /* ptype_list *pt;
1314 int low;
1315 int high;
1316 int sigsize;
1317
1318 sigsize = getsigsize( ptfig );
1319 low = (index % sigsize);
1320 high = (index / sigsize);
1321 for (pt = ptfig->BKSIG; pt; pt = pt->NEXT)
1322 if (pt->TYPE == high) break;
1323 if (pt != NULL) {
1324 ptsig = (losig_list *)(pt->DATA) + low;
1325 if (ptsig->INDEX == index)
1326 return ptsig;
1327 }
1328 */
1329 if (index<=ptfig->BKSIG.maxindex)
1330 return mbk_NewBKSIG_getindex(ptfig, index);
1331
1332 avt_errmsg (MBK_ERRMSG, "032", AVT_FATAL, index, ptfig->NAME);
1333 return NULL; /* never reached */
1334 }
1335
1336 /*******************************************************************************
1337 * function lofigchain_local() *
1338 * For each signal, construct the list of connectors associated *
1339 * with the signal.(Field USER of the "losig" structure with *
1340 * the code "LOFIGCHAIN_LOCAL") *
1341 * This provide the "dual" representation of the net-list *
1342 *******************************************************************************/
1343
1344 void dellofigchain_local(ptfig)
1345 lofig_list *ptfig;
1346 {
1347 losig_list *ptsig = NULL;
1348 ptype_list *ptype = NULL;
1349
1350 if (ptfig->MODE == 'P')
1351 return;
1352
1353 /* cleaning ... */
1354 for (ptsig = ptfig->LOSIG; ptsig; ptsig = ptsig->NEXT) {
1355 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN_LOCAL);
1356 if (ptype != (ptype_list *)NULL) {
1357 freechain((chain_list *)ptype->DATA);
1358 ptype->DATA = (void *)NULL;
1359 } else
1360 ptsig->USER = delptype(ptsig->USER, (long)LOFIGCHAIN_LOCAL);
1361 }
1362 }
1363
1364 void lofigchain_local(ptfig)
1365 lofig_list *ptfig;
1366 {
1367 locon_list *ptcon = NULL;
1368 losig_list *ptsig = NULL;
1369 loins_list *ptins = NULL;
1370 lotrs_list *pttrs = NULL;
1371 ptype_list *ptype = NULL;
1372
1373 if (ptfig->MODE == 'P') {
1374 /*
1375 (void)fflush(stdout);
1376 (void)fprintf(stderr, "*** mbk error ***\nlofigchain impossible ");
1377 (void)fprintf(stderr, ": figure %s is interface only\n",
1378 ptfig->NAME);
1379 EXIT(1);
1380 */
1381 return;
1382 }
1383
1384 /* cleaning ... */
1385 for (ptsig = ptfig->LOSIG; ptsig; ptsig = ptsig->NEXT) {
1386 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN_LOCAL);
1387 if (ptype != (ptype_list *)NULL) {
1388 freechain((chain_list *)ptype->DATA);
1389 ptype->DATA = (void *)NULL;
1390 } else
1391 ptsig->USER = addptype(ptsig->USER, (long)LOFIGCHAIN_LOCAL, (void *)NULL);
1392 }
1393
1394 /* scan connector list */
1395 for (ptcon=ptfig->LOCON; ptcon; ptcon=ptcon->NEXT) {
1396 ptsig = ptcon->SIG;
1397 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN_LOCAL);
1398 ptype->DATA = (void *)addchain((chain_list *)ptype->DATA, (void *)ptcon);
1399 }
1400
1401 /* scan instance list */
1402 for (ptins =ptfig->LOINS; ptins; ptins=ptins->NEXT) {
1403 for (ptcon=ptins->LOCON; ptcon; ptcon=ptcon->NEXT) {
1404 ptsig=ptcon->SIG;
1405 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN_LOCAL);
1406 ptype->DATA = (void *)addchain((chain_list *)ptype->DATA,
1407 (void *)ptcon);
1408 }
1409 }
1410
1411 /* scan transistor list */
1412 for (pttrs = ptfig->LOTRS; pttrs; pttrs = pttrs->NEXT) {
1413 ptsig = pttrs->GRID->SIG;
1414 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN_LOCAL);
1415 ptype->DATA = (void *)addchain((chain_list *)ptype->DATA,
1416 (void *)pttrs->GRID);
1417 ptsig = pttrs->SOURCE->SIG;
1418 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN_LOCAL);
1419 ptype->DATA = (void *)addchain((chain_list *)ptype->DATA,
1420 (void *)pttrs->SOURCE);
1421 ptsig = pttrs->DRAIN->SIG;
1422 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN_LOCAL);
1423 ptype->DATA = (void *)addchain((chain_list *)ptype->DATA,
1424 (void *)pttrs->DRAIN);
1425 if (pttrs->BULK!=NULL)
1426 {
1427 ptsig = pttrs->BULK->SIG;
1428 if( ptsig ) {
1429 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN_LOCAL);
1430 ptype->DATA = (void *)addchain((chain_list *)ptype->DATA,
1431 (void *)pttrs->BULK);
1432 }
1433 }
1434 }
1435 if (DEBUG_MODE == 'Y')
1436 (void)printf("--- mbk --- lofigchain_local %s\n", ptfig->NAME);
1437 }
1438
1439 /*******************************************************************************
1440 * function addoptparam() *
1441 *******************************************************************************/
1442 optparam_list *
1443 addoptparam(optparam_list *ptheadparam, char *param, float value, char *expr)
1444 {
1445 optparam_list *newparam;
1446 char buf[256];
1447
1448 newparam = (optparam_list *)mbkalloc(sizeof(optparam_list));
1449 newparam->EQT_EXPR=NULL;
1450 newparam->NEXT = ptheadparam;
1451
1452 newparam->TAG =expr?'$':' ';
1453 downstr(param, buf);
1454 newparam->UNAME.SPECIAL = namealloc(buf);
1455 if (expr) newparam->UDATA.EXPR = expr;
1456 else newparam->UDATA.VALUE = value;
1457
1458 return newparam;
1459 }
1460
1461 /*******************************************************************************
1462 * function getoptparam() *
1463 *******************************************************************************/
1464 float
1465 getoptparam(optparam_list *ptheadparam, void *param, char **expr, int *status)
1466 {
1467 char buf[256];
1468 optparam_list *ptparamlist;
1469 char *testunknown;
1470
1471
1472 if (ptheadparam != NULL) {
1473 downstr((char *)param, buf);
1474 testunknown = namealloc(buf);
1475 for (ptparamlist = ptheadparam; ptparamlist; ptparamlist = ptparamlist->NEXT) {
1476 if (ptparamlist->TAG==' ' && ptparamlist->UNAME.SPECIAL == testunknown) {
1477 if (expr) *expr = NULL;
1478 if (status) *status = 1;
1479 return ptparamlist->UDATA.VALUE;
1480 }
1481 else if (ptparamlist->TAG=='$' && ptparamlist->UNAME.SPECIAL == testunknown) {
1482 if (expr) *expr = ptparamlist->UDATA.EXPR;
1483 if (status) *status = 2;
1484 return 0.0;
1485 }
1486 }
1487 }
1488
1489 if (expr) *expr = NULL;
1490 if (status) *status = 0;
1491 return 0.0;
1492 }
1493
1494 /*******************************************************************************
1495 * function freeoptparams() *
1496 *******************************************************************************/
1497 void
1498 freeoptparams(optparam_list *ptheadparam)
1499 {
1500 optparam_list *ptparam;
1501 optparam_list *ptnextparam;
1502
1503 for (ptparam = ptheadparam; ptparam; ptparam = ptnextparam) {
1504 ptnextparam = ptparam->NEXT;
1505 if (ptparam->EQT_EXPR!=NULL && --((eqt_node *)ptparam->EQT_EXPR)->REF_COUNT==0)
1506 eqt_freenode(ptparam->EQT_EXPR);
1507 mbkfree(ptparam);
1508 }
1509 }
1510
1511 /*******************************************************************************
1512 * function lofigchain() *
1513 * For each signal, construct the list of connectors associated *
1514 * with the signal.(Field USER of the "losig" structure with *
1515 * the code "LOFIGCHAIN") *
1516 * This provide the "dual" representation of the net-list *
1517 *******************************************************************************/
1518 void lofigchain(ptfig)
1519 lofig_list *ptfig;
1520 {
1521 locon_list *ptcon = NULL;
1522 losig_list *ptsig = NULL;
1523 loins_list *ptins = NULL;
1524 lotrs_list *pttrs = NULL;
1525 ptype_list *ptype = NULL;
1526
1527 if (ptfig->MODE == 'P') {
1528 /*
1529 (void)fflush(stdout);
1530 (void)fprintf(stderr, "*** mbk error ***\nlofigchain impossible ");
1531 (void)fprintf(stderr, ": figure %s is interface only\n",
1532 ptfig->NAME);
1533 EXIT(1);
1534 */
1535 return;
1536 }
1537
1538 /* cleaning ... */
1539 for (ptsig = ptfig->LOSIG; ptsig; ptsig = ptsig->NEXT) {
1540 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN);
1541 if (ptype != (ptype_list *)NULL) {
1542 freechain((chain_list *)ptype->DATA);
1543 ptype->DATA = (void *)NULL;
1544 } else
1545 ptsig->USER = addptype(ptsig->USER, (long)LOFIGCHAIN, (void *)NULL);
1546 }
1547
1548 /* scan connector list */
1549 for (ptcon=ptfig->LOCON; ptcon; ptcon=ptcon->NEXT) {
1550 ptsig = ptcon->SIG;
1551 if(ptsig) {
1552 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN);
1553 ptype->DATA = (void *)addchain((chain_list *)ptype->DATA, (void *)ptcon);
1554 }
1555 }
1556
1557 /* scan instance list */
1558 for (ptins =ptfig->LOINS; ptins; ptins=ptins->NEXT) {
1559 for (ptcon=ptins->LOCON; ptcon; ptcon=ptcon->NEXT) {
1560 ptsig=ptcon->SIG;
1561 if(ptsig){
1562 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN);
1563 ptype->DATA = (void *)addchain((chain_list *)ptype->DATA,
1564 (void *)ptcon);
1565 }
1566 }
1567 }
1568
1569 /* scan transistor list */
1570 for (pttrs = ptfig->LOTRS; pttrs; pttrs = pttrs->NEXT) {
1571 ptsig = pttrs->GRID->SIG;
1572 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN);
1573 ptype->DATA = (void *)addchain((chain_list *)ptype->DATA,
1574 (void *)pttrs->GRID);
1575 ptsig = pttrs->SOURCE->SIG;
1576 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN);
1577 ptype->DATA = (void *)addchain((chain_list *)ptype->DATA,
1578 (void *)pttrs->SOURCE);
1579 ptsig = pttrs->DRAIN->SIG;
1580 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN);
1581 ptype->DATA = (void *)addchain((chain_list *)ptype->DATA,
1582 (void *)pttrs->DRAIN);
1583 if (pttrs->BULK!=NULL)
1584 {
1585 ptsig = pttrs->BULK->SIG;
1586 if( ptsig ) {
1587 ptype = getptype(ptsig->USER, (long)LOFIGCHAIN);
1588 ptype->DATA = (void *)addchain((chain_list *)ptype->DATA,
1589 (void *)pttrs->BULK);
1590 }
1591 }
1592 }
1593 if (DEBUG_MODE == 'Y')
1594 (void)printf("--- mbk --- lofigchain %s\n", ptfig->NAME);
1595 }
1596
1597 /*******************************************************************************
1598 * function getsigname() *
1599 * choose the least concatened signal name *
1600 *******************************************************************************/
1601 char *getsigname(ptsig)
1602 losig_list *ptsig;
1603 {
1604 chain_list *ptscan;
1605 char *ptchar;
1606 char buffer[50];
1607 char *result = NULL, *newc;
1608 register int nseparmin = 1000;
1609 int l0, l1;
1610
1611 if (ptsig == NULL)
1612 return NULL;
1613
1614 for (ptscan = ptsig->NAMECHAIN; ptscan; ptscan = ptscan->NEXT) {
1615 register int nsepar = 0;
1616 newc=(char *)ptscan->DATA;
1617 if (newc != NULL) {
1618 for (ptchar = newc; *ptchar != '\0'; ptchar++)
1619 if (*ptchar == SEPAR)
1620 nsepar++;
1621 if (nsepar < nseparmin) {
1622 nseparmin = nsepar;
1623 result = newc;
1624 }
1625 else if (nsepar == nseparmin) {
1626 if ((l0=strlen(newc)) < (l1=strlen(result)) || (l0==l1 && mbk_casestrcmp(newc,result)<0)) {
1627 result = newc;
1628 }
1629 }
1630 }
1631 }
1632 if (!result) {
1633 (void)sprintf(buffer, "mbk_%ld", ptsig->INDEX);
1634 result = namealloc(buffer);
1635 }
1636 return result;
1637 }
1638
1639 /*******************************************************************************
1640 * function mbkisgnalname() *
1641 * Return 1 if signal is named 'name', 0 else. name must be nameallocated. *
1642 *******************************************************************************/
1643 int mbkissignalname( losig_list *losig, char *name )
1644 {
1645 chain_list *chain ;
1646
1647 if( !losig )
1648 return 0;
1649
1650 for( chain = losig->NAMECHAIN ; chain ; chain = chain->NEXT ) {
1651 if( (char*)chain->DATA == name )
1652 return 1 ;
1653 }
1654
1655 return 0;
1656 }
1657
1658 /*******************************************************************************
1659 * function viewlo() *
1660 * display on screen the content of all logical figures *
1661 *******************************************************************************/
1662 void viewlo()
1663 {
1664 lofig_list *ptfig;
1665
1666 if (HEAD_LOFIG == NULL) {
1667 avt_errmsg (MBK_ERRMSG, "033", AVT_ERROR);
1668 return;
1669 } else for (ptfig = HEAD_LOFIG; ptfig; ptfig = ptfig->NEXT)
1670 viewlofig(ptfig);
1671 }
1672
1673 /*******************************************************************************
1674 * function viewlofig() *
1675 * display on screen the content of logical figure ptfig *
1676 *******************************************************************************/
1677 void viewlofig(ptfig)
1678 lofig_list *ptfig;
1679 {
1680 locon_list *ptcon;
1681 losig_list *ptsig;
1682 loins_list *ptins;
1683 lotrs_list *pttrs;
1684 chain_list *scanchain;
1685 ptype_list *pt;
1686
1687 if (ptfig->NAME == NULL)
1688 (void)printf("!!! figure without name !!! /n");
1689 else
1690 (void)printf("\nfigure : %-20s mode : %c\n", ptfig->NAME, ptfig->MODE);
1691
1692 if (ptfig->LOCON == NULL)
1693 (void)printf(" |---empty connector list\n");
1694 else
1695 {
1696 for (ptcon = ptfig->LOCON; ptcon; ptcon = ptcon->NEXT)
1697 viewlofigcon(ptcon);
1698
1699 pt = getptype( ptfig->USER, PH_INTERF );
1700 if( pt )
1701 {
1702 (void)printf(" |---connector list physical order\n");
1703 for( scanchain = (chain_list*)(pt->DATA); scanchain ; scanchain = scanchain->NEXT )
1704 (void)printf(" | |---%s\n",(char*)(scanchain->DATA) );
1705 (void)printf(" |\n");
1706 }
1707 }
1708
1709 if (ptfig->LOSIG == NULL)
1710 (void)printf(" |---empty signal list\n");
1711 else for (ptsig = ptfig->LOSIG; ptsig; ptsig = ptsig->NEXT)
1712 viewlosig(ptsig);
1713
1714 if (ptfig->LOINS == NULL)
1715 (void)printf(" |---empty instance list\n");
1716 else for (ptins = ptfig->LOINS; ptins; ptins = ptins->NEXT)
1717 viewloins(ptins);
1718
1719 if (ptfig->LOTRS == NULL)
1720 (void)printf(" |---empty transistor list\n");
1721 else for (pttrs = ptfig->LOTRS; pttrs; pttrs = pttrs->NEXT)
1722 viewlotrs(pttrs);
1723
1724 if (ptfig->USER != NULL)
1725 {
1726 (void)printf(" |---USER field\n");
1727 for( pt = ptfig->USER ; pt ; pt = pt->NEXT )
1728 (void)printf(" | |-- %ld\n",pt->TYPE);
1729 }
1730 else
1731 (void)printf(" |---empty USER field\n");
1732
1733 (void)printf(" | \n");
1734 }
1735
1736 /*******************************************************************************
1737 * function viewlofigcon() *
1738 *******************************************************************************/
1739 void viewlofigcon(ptcon)
1740 locon_list *ptcon;
1741 {
1742 num_list *scannum;
1743 ptype_list *scanptype;
1744 chain_list *scanchain;
1745
1746 if (ptcon->NAME == NULL)
1747 (void)printf(" |--- !!! connector without name !!!\n");
1748 else
1749 (void)printf(" |---connector : \"%s\"\n", ptcon->NAME);
1750 (void)printf(" | |---direction : %c\n", ptcon->DIRECTION);
1751 if (ptcon->SIG == NULL)
1752 (void)printf(" | |---no signal\n");
1753 else
1754 (void)printf(" | |---signal : %ld\n", ptcon->SIG->INDEX);
1755 if (ptcon->ROOT == NULL)
1756 (void)printf(" |---no root\n");
1757 else
1758 (void)printf(" | |---root : %s\n",
1759 ((char *)(((lofig_list *)(ptcon->ROOT))->NAME)));
1760 (void)printf(" | |---type : %c \n", ptcon->TYPE);
1761
1762 (void)printf(" | |---USER list\n");
1763 for( scanptype = ptcon->USER ; scanptype ; scanptype = scanptype->NEXT )
1764 {
1765 switch( scanptype->TYPE )
1766 {
1767 case PNODENAME:
1768 (void)printf(" | | |---PNODENAME\n");
1769 for( scanchain = (chain_list*)(scanptype->DATA);
1770 scanchain;
1771 scanchain = scanchain->NEXT )
1772 (void)printf(" | | | |---%s\n", (char*)(scanchain->DATA)?(char*)(scanchain->DATA):"NULL" );
1773 break;
1774 default:
1775 (void)printf(" | | | |---%ld\n",scanptype->TYPE);
1776 }
1777 }
1778
1779 if(ptcon->PNODE == NULL)
1780 (void)printf(" | |---no node\n");
1781 else {
1782 (void)printf(" | |---node\n");
1783 for(scannum = ptcon->PNODE; scannum; scannum = scannum->NEXT )
1784 (void)printf(" | | |---%ld\n",scannum->DATA);
1785
1786 }
1787
1788 (void)printf(" |\n");
1789 }
1790
1791 /*******************************************************************************
1792 * function viewlosig() *
1793 *******************************************************************************/
1794 void viewlosig_sub(losig_list *ptsig, int resume)
1795 {
1796 chain_list *ptchain;
1797 lowire_list *scanwire;
1798 chain_list *scanctc;
1799 loctc_list *ptctc;
1800 char levelrc;
1801 ptype_list *ptptype;
1802 num_list *scannum;
1803
1804 (void)printf(" |---signal : %ld \n" , ptsig->INDEX);
1805 if (ptsig->NAMECHAIN == NULL)
1806 (void)printf(" | |---no alias names\n");
1807 else for (ptchain = ptsig->NAMECHAIN; ptchain; ptchain = ptchain->NEXT) {
1808 if (ptchain->DATA == NULL)
1809 (void)printf(" | |--- !!! empty name !!!\n");
1810 else
1811 (void)printf(" | |---alias : \"%s\"\n", (char *)ptchain->DATA);
1812 }
1813 (void)printf(" | |---type : %c\n" , ptsig->TYPE);
1814
1815 levelrc = rclevel( ptsig );
1816
1817 if( levelrc == MBK_RC_A )
1818 (void)printf(" | |---no parasitic data\n");
1819 else {
1820 (void)printf(" | |---parasitic data\n");
1821 (void)printf(" | | |---capacitance : %g\n" , rcn_getcapa(NULL, ptsig));
1822 if( levelrc == MBK_RC_C || levelrc == MBK_RC_E ) {
1823 (void)printf(" | | |---wire list\n");
1824 for( scanwire = ptsig->PRCN->PWIRE ; scanwire != NULL ; scanwire = scanwire->NEXT )
1825 (void)printf(" | | | |-n1=%3ld n2=%3ld r=%g c=%g\n",
1826 scanwire->NODE1,
1827 scanwire->NODE2,
1828 scanwire->RESI,
1829 scanwire->CAPA );
1830 }
1831 else
1832 (void)printf(" | | |---no wire\n");
1833 if( levelrc == MBK_RC_D || levelrc == MBK_RC_E ) {
1834 (void)printf(" | | |---crosstalk capacitance list\n");
1835 for( scanctc = ptsig->PRCN->PCTC ; scanctc != NULL ; scanctc = scanctc->NEXT ) {
1836 ptctc = (loctc_list*)scanctc->DATA;
1837 (void)printf(" | | | |-S1=%3ld N1=%3ld S2=%3ld N2=%3ld Capa=%g.\n",
1838 ptctc->SIG1->INDEX,
1839 ptctc->NODE1,
1840 ptctc->SIG2->INDEX,
1841 ptctc->NODE2,
1842 ptctc->CAPA
1843 );
1844 }
1845 }
1846 else
1847 (void)printf(" | | |---no crosstalk capacitance\n");
1848 (void)printf(" | | |---%ld node\n",ptsig->PRCN->NBNODE);
1849 }
1850 (void)printf(" | |---USER list\n");
1851 for( ptptype = ptsig->USER ; ptptype ; ptptype = ptptype->NEXT )
1852 {
1853 switch( ptptype->TYPE )
1854 {
1855 case LOFIGCHAIN:
1856 printf( " | | |-LOFIGCHAIN\n" );
1857 for( ptchain = (chain_list*)ptptype->DATA ; ptchain ; ptchain = ptchain->NEXT )
1858 {
1859 printf( " | | | |-%s ",((locon_list*)ptchain->DATA)->NAME);
1860 switch( ((locon_list*)ptchain->DATA)->TYPE )
1861 {
1862 case 'T':
1863 printf( "(T%c : %s) ",MLO_IS_TRANSN(((lotrs_list*)((locon_list*)ptchain->DATA)->ROOT)->TYPE)?'N':'P',((lotrs_list*)((locon_list*)ptchain->DATA)->ROOT)->TRNAME ? ((lotrs_list*)((locon_list*)ptchain->DATA)->ROOT)->TRNAME : "No name" );
1864 break;
1865 case 'I':
1866 printf( "(I : %s) ",((loins_list*)((locon_list*)ptchain->DATA)->ROOT)->INSNAME ? ((loins_list*)((locon_list*)ptchain->DATA)->ROOT)->INSNAME : "No name" );
1867 break;
1868 case 'E':
1869 printf( "(Figure) " );
1870 break;
1871 default:
1872 printf( "Not a valid type('%c') ", ((locon_list*)ptchain->DATA)->TYPE);
1873 }
1874 if (!resume)
1875 {
1876 for( scannum = ((locon_list*)ptchain->DATA)->PNODE ; scannum ; scannum = scannum->NEXT )
1877 printf( "%ld ", scannum->DATA );
1878 }
1879 printf( "\n" );
1880 }
1881 break;
1882 default:
1883 break;
1884 }
1885 }
1886 {
1887 }
1888 (void)printf(" | \n");
1889 }
1890
1891 void viewlosig(losig_list *ptsig)
1892 {
1893 viewlosig_sub(ptsig, 0);
1894 }
1895
1896 /*******************************************************************************
1897 * function viewloins() *
1898 *******************************************************************************/
1899 void viewloins(ptins)
1900 loins_list *ptins;
1901 {
1902 locon_list *ptcon;
1903 chain_list *scanchain;
1904 ptype_list *pt;
1905
1906 if (ptins->INSNAME == NULL)
1907 (void)printf(" |--- !!! no instance name !!!\n");
1908 else
1909 (void)printf(" |---instance : %s\n", ptins->INSNAME);
1910 if (ptins->FIGNAME == NULL)
1911 (void)printf(" | |--- !!! no instance model !!!\n");
1912 else
1913 (void)printf(" | |---model : %s \n" , ptins->FIGNAME);
1914 if (ptins->LOCON == NULL)
1915 (void)printf(" | |---empty list of connectors\n");
1916 else
1917 {
1918 for (ptcon = ptins->LOCON; ptcon != NULL; ptcon = ptcon->NEXT)
1919 viewloinscon(ptcon);
1920 pt = getptype( ptins->USER, PH_INTERF );
1921 if( pt )
1922 {
1923 (void)printf(" | |---connector list physical order\n");
1924 for( scanchain = (chain_list*)(pt->DATA); scanchain ; scanchain = scanchain->NEXT )
1925 (void)printf(" | | |---%s\n",(char*)(scanchain->DATA) );
1926 (void)printf(" | |\n");
1927 }
1928 }
1929 if (ptins->USER != NULL)
1930 (void)printf(" | |---non empty USER field\n");
1931 (void)printf(" | \n");
1932 }
1933
1934 /*******************************************************************************
1935 * function viewlotrs() *
1936 *******************************************************************************/
1937 void viewlotrs(pttrs)
1938 lotrs_list *pttrs;
1939 {
1940 (void)printf(" |---transistor\n");
1941 if (MLO_IS_TRANSN(pttrs->TYPE))
1942 (void)printf(" | |---type : TRANSN \n");
1943 else if (MLO_IS_TRANSP(pttrs->TYPE))
1944 (void)printf(" | |---type : TRANSP \n");
1945 else
1946 (void)printf(" | |---illegal type\n");
1947 if (pttrs->TRNAME != NULL )
1948 (void)printf(" | |---name : %s\n", pttrs->TRNAME );
1949 else
1950 (void)printf(" | |---no name\n" );
1951
1952 if (pttrs->SOURCE == NULL)
1953 (void)printf(" | |--- !!! no signal on source !!! \n");
1954 else
1955 viewloinscon( pttrs->SOURCE );
1956
1957 if (pttrs->GRID == NULL)
1958 (void)printf(" | |--- !!! no signal on grid !!!\n");
1959 else
1960 viewloinscon( pttrs->GRID );
1961
1962 if (pttrs->DRAIN == NULL)
1963 (void)printf(" | |--- !!! no signal on drain !!!\n");
1964 else
1965 viewloinscon( pttrs->DRAIN );
1966
1967 if (pttrs->BULK == NULL)
1968 (void)printf(" | |--- !!! no signal on bulk !!!\n");
1969 else
1970 viewloinscon( pttrs->BULK );
1971
1972 (void)printf(" | |---x : %ld\n", pttrs->X);
1973 (void)printf(" | |---y : %ld\n", pttrs->Y);
1974 (void)printf(" | |---width : %ld\n", pttrs->WIDTH);
1975 (void)printf(" | |---length : %ld\n", pttrs->LENGTH);
1976 (void)printf(" | |---ps : %ld\n", pttrs->PS);
1977 (void)printf(" | |---pd : %ld\n", pttrs->PD);
1978 (void)printf(" | |---xs : %ld\n", pttrs->XS);
1979 (void)printf(" | |---xd : %ld\n", pttrs->XD);
1980 if (pttrs->USER != NULL)
1981 (void)printf(" | |---non empty USER field\n");
1982 (void)printf(" |\n");
1983 }
1984
1985 /*******************************************************************************
1986 * function viewloinscon() *
1987 *******************************************************************************/
1988 void viewloinscon(ptcon)
1989 locon_list *ptcon;
1990 {
1991 num_list *scannum;
1992 ptype_list *scanptype;
1993 chain_list *scanchain;
1994
1995 if (ptcon->NAME == NULL)
1996 (void)printf(" | |---no connector name\n");
1997 else
1998 (void)printf(" | |---connector : \"%s\"\n" , ptcon->NAME);
1999 (void)printf(" | | |---direction : %c\n" , ptcon->DIRECTION);
2000 if (ptcon->SIG == NULL)
2001 (void)printf(" | | |---no signal\n");
2002 else
2003 (void)printf(" | | |---signal : %ld\n" , ptcon->SIG->INDEX);
2004 if ((ptcon->ROOT) == NULL)
2005 (void)printf(" | | |---no root\n");
2006 else
2007 switch( ptcon->TYPE )
2008 {
2009 case 'I':
2010 (void)printf(" | | |---root : %s\n" , ((char*)(((loins_list *)(ptcon->ROOT))->INSNAME)));
2011 break;
2012 case 'T':
2013 (void)printf(" | | |---root : %s\n" ,
2014 ((lotrs_list*)(ptcon->ROOT))->TRNAME?((lotrs_list*)(ptcon->ROOT))->TRNAME:"no transistor name" );
2015 break;
2016 default:
2017 (void)printf(" | | |---root : *** BAD TYPE ***\n" );
2018 }
2019 (void)printf(" | | |---type : %c\n" , ptcon->TYPE);
2020 if(ptcon->PNODE == NULL)
2021 (void)printf(" | | |---no node\n");
2022 else {
2023 (void)printf(" | | |---node\n");
2024 for(scannum = ptcon->PNODE; scannum; scannum = scannum->NEXT )
2025 (void)printf(" | | | |---%ld\n",scannum->DATA);
2026 }
2027 (void)printf(" | | |---USER list\n");
2028 for( scanptype = ptcon->USER ; scanptype ; scanptype = scanptype->NEXT )
2029 {
2030 switch( scanptype->TYPE )
2031 {
2032 case PNODENAME:
2033 (void)printf(" | | | |---PNODENAME\n");
2034 for( scanchain = (chain_list*)(scanptype->DATA);
2035 scanchain;
2036 scanchain = scanchain->NEXT )
2037 (void)printf(" | | | | |---%s\n", (char*)(scanchain->DATA)?(char*)(scanchain->DATA):"NULL" );
2038 break;
2039 default:
2040 (void)printf(" | | | |---%ld\n",scanptype->TYPE);
2041 }
2042 }
2043 (void)printf(" | | \n");
2044 }
2045
2046 /*******************************************************************************
2047 * function getsigsize() *
2048 *******************************************************************************/
2049
2050 int getsigsize( ptfig )
2051 lofig_list *ptfig;
2052 {
2053 ptype_list *ptl;
2054
2055 ptl = getptype( ptfig->USER, PTSIGSIZE );
2056 if( ptl )
2057 return( (int)((long)(ptl->DATA)) );
2058
2059 return( SIGSIZE );
2060 }
2061
2062 /*******************************************************************************
2063 * function setsigsize() *
2064 *******************************************************************************/
2065
2066 void setsigsize( ptfig, nb )
2067 lofig_list *ptfig;
2068 int nb;
2069 {
2070 ptype_list *ptl;
2071
2072 if( ptfig->BKSIG.TAB )
2073 {
2074 avt_errmsg (MBK_ERRMSG, "034", AVT_FATAL);
2075 }
2076
2077 ptl = getptype( ptfig->USER, PTSIGSIZE );
2078 if( !ptl )
2079 ptfig->USER = addptype( ptfig->USER, PTSIGSIZE, (void*)((long)nb) );
2080 else
2081 ptl->DATA = (void*)((long)nb);
2082 }
2083
2084
2085 int getnumberoflosig( ptfig )
2086 lofig_list *ptfig;
2087 {
2088 long bkmax;
2089 long max;
2090 long bkmaxmax;
2091 losig_list *blk;
2092 long sz;
2093 long i;
2094 ptype_list *ptl;
2095
2096 if (!ptfig->BKSIG.TAB ) return 0;
2097 return ptfig->BKSIG.maxindex;
2098 /*
2099 sz = getsigsize( ptfig );
2100 bkmax = LONG_MAX;
2101 max = -1;
2102
2103 do {
2104 bkmaxmax = bkmax;
2105 bkmax = -1;
2106
2107 for( ptl = ptfig->BKSIG ; ptl ; ptl = ptl->NEXT ) {
2108 if( ptl->TYPE > bkmax && ptl->TYPE < bkmaxmax ) {
2109 bkmax = ptl->TYPE;
2110 blk = ptl->DATA;
2111 }
2112 }
2113 if( bkmax == -1 ) break;
2114
2115 max = 0;
2116
2117 for( i = 0 ; i<sz ; i++ ) {
2118 if( blk[i].INDEX > max )
2119 max = blk[i].INDEX;
2120 }
2121
2122 }
2123 while( !max );
2124
2125 return max;
2126 */
2127 }
2128
2129 /*******************************************************************************
2130 * function for cleaning USER field of structures. *
2131 *******************************************************************************/
2132
2133 void delloconuser( ptlocon )
2134 locon_list *ptlocon;
2135 {
2136 ptype_list *scanptype;
2137 ptype_list *next;
2138 ptype_list *prev;
2139 int del;
2140
2141 prev = NULL;
2142 for( scanptype = ptlocon->USER ; scanptype ; scanptype = next )
2143 {
2144 next = scanptype->NEXT;
2145 del = 0;
2146
2147 switch( scanptype->TYPE )
2148 {
2149 case PNODENAME:
2150 freechain( scanptype->DATA );
2151 del = 1;
2152 break;
2153 default:
2154 #ifdef MBK_TRACE_BAD_PTYPE
2155 fprintf( stderr, "WARNING in delloconuser() : unknown ptype %08X\n",
2156 (unsigned int)scanptype->TYPE
2157 );
2158 #endif
2159 break;
2160 }
2161 /*
2162 if( del )
2163 {
2164 if( !prev )
2165 ptlocon->USER = next;
2166 else
2167 prev->NEXT = next;
2168 scanptype->NEXT = NULL;
2169 freeptype( scanptype );
2170 }
2171 else
2172 prev = scanptype;
2173 */
2174 }
2175 freeptype(ptlocon->USER); ptlocon->USER=NULL;
2176 }
2177
2178 //typedef struct eqt_param eqt_param;
2179 //extern void eqt_free_param (eqt_param *param);
2180
2181 void dellofiguser( ptlofig )
2182 lofig_list *ptlofig;
2183 {
2184 ptype_list *scanptype;
2185 ptype_list *next;
2186 ptype_list *prev;
2187 int del;
2188
2189 prev = NULL;
2190 for( scanptype = ptlofig->USER ; scanptype ; scanptype = next )
2191 {
2192 next = scanptype->NEXT;
2193 del = 0;
2194
2195 switch( scanptype->TYPE )
2196 {
2197 case PARAM_CONTEXT:
2198 eqt_free_param((eqt_param*)scanptype->DATA);
2199 break;
2200 case OPT_PARAMS:
2201 freeoptparams(scanptype->DATA);
2202 break;
2203 case PH_REAL_INTERF:
2204 case PH_INTERF:
2205 freechain( scanptype->DATA );
2206 del = 1;
2207 break;
2208 case PTSIGSIZE:
2209 case LOFIG_LOCK:
2210 del = 1;
2211 break;
2212 case LOFIG_QUICK_SIG_HT:
2213 case LOFIG_QUICK_INS_HT:
2214 case LOFIG_QUICK_TRS_HT:
2215 delht_v2((ht_v2 *)scanptype->DATA );
2216 del=1;
2217 break;
2218 case LOFIG_INFO:
2219 mbkfree(scanptype->DATA);
2220 break;
2221 case 0x00079350: // SPEF_INDEX
2222 delit((it *)scanptype->DATA);
2223 break;
2224 default:
2225 #ifdef MBK_TRACE_BAD_PTYPE
2226 fprintf( stderr, "WARNING in dellofiguser() : unknown ptype %08X\n",
2227 (unsigned int)scanptype->TYPE
2228 );
2229 #endif
2230 break;
2231 }
2232 /*
2233 if( del )
2234 {
2235 if( !prev )
2236 ptlofig->USER = next;
2237 else
2238 prev->NEXT = next;
2239 scanptype->NEXT = NULL;
2240 freeptype( scanptype );
2241 }
2242 else
2243 prev = scanptype;
2244 */
2245 }
2246 freeptype(ptlofig->USER); ptlofig->USER=NULL;
2247 }
2248
2249 void delloinsuser( ptloins )
2250 loins_list *ptloins;
2251 {
2252 ptype_list *scanptype;
2253 ptype_list *next;
2254 ptype_list *prev;
2255 int del;
2256
2257 prev = NULL;
2258 for( scanptype = ptloins->USER ; scanptype ; scanptype = next )
2259 {
2260 next = scanptype->NEXT;
2261 del = 0;
2262
2263 switch( scanptype->TYPE )
2264 {
2265 case PARAM_CONTEXT:
2266 eqt_free_param((eqt_param*)scanptype->DATA);
2267 break;
2268 case PH_INTERF:
2269 case PH_REAL_INTERF: // should not happen for now, perhaps later
2270 freechain( scanptype->DATA );
2271 del = 1;
2272 break;
2273 default:
2274 #ifdef MBK_TRACE_BAD_PTYPE
2275 fprintf( stderr, "WARNING in delloinsuser() : unknown ptype %08X\n",
2276 (unsigned int)scanptype->TYPE
2277 );
2278 #endif
2279 break;
2280 }
2281 /*
2282 if( del )
2283 {
2284 if( !prev )
2285 ptloins->USER = next;
2286 else
2287 prev->NEXT = next;
2288 scanptype->NEXT = NULL;
2289 freeptype( scanptype );
2290 }
2291 else
2292 prev = scanptype;
2293 */
2294 }
2295 freeptype(ptloins->USER); ptloins->USER=NULL;
2296 }
2297
2298 void dellotrsuser( ptlotrs )
2299 lotrs_list *ptlotrs;
2300 {
2301 ptype_list *scanptype;
2302 ptype_list *next;
2303 ptype_list *prev;
2304 int del;
2305
2306 prev = NULL;
2307 for( scanptype = ptlotrs->USER ; scanptype ; scanptype = next )
2308 {
2309 next = scanptype->NEXT;
2310 del = 0;
2311
2312 switch( scanptype->TYPE )
2313 {
2314 case PARAM_CONTEXT:
2315 eqt_free_param((eqt_param *)scanptype->DATA);
2316 break;
2317 case OPT_PARAMS:
2318 freeoptparams((optparam_list *)scanptype->DATA);
2319 break;
2320 case MCC_COMPUTED_KEY:
2321 freechain((chain_list *)scanptype->DATA);
2322 break;
2323 default:
2324 #ifdef MBK_TRACE_BAD_PTYPE
2325 fprintf( stderr, "WARNING in dellotrsuser() : unknown ptype %08X\n",
2326 (unsigned int)scanptype->TYPE
2327 );
2328 #endif
2329 break;
2330 }
2331 /*
2332 if( del )
2333 {
2334 if( !prev )
2335 ptlotrs->USER = next;
2336 else
2337 prev->NEXT = next;
2338 scanptype->NEXT = NULL;
2339 freeptype( scanptype );
2340 }
2341 else
2342 prev = scanptype;
2343 */
2344 }
2345 freeptype(ptlotrs->USER); ptlotrs->USER=NULL;
2346 }
2347
2348 void dellosiguser( ptlosig )
2349 losig_list *ptlosig;
2350 {
2351 ptype_list *scanptype;
2352 ptype_list *next;
2353 ptype_list *prev;
2354 chain_list *cl;
2355 int del;
2356
2357 prev = NULL;
2358 for( scanptype = ptlosig->USER ; scanptype ; scanptype = next )
2359 {
2360 next = scanptype->NEXT;
2361 del = 0;
2362
2363 switch( scanptype->TYPE )
2364 {
2365 case LOSIGALIM:
2366 del = 1;
2367 break ;
2368 case LOFIGCHAIN:
2369 case LOFIGCHAIN_LOCAL:
2370 freechain( scanptype->DATA );
2371 del = 1;
2372 break;
2373 case MBK_VCARD_NODES:
2374 for (cl=(chain_list *)scanptype->DATA; cl!=NULL; cl=cl->NEXT)
2375 mbkfree(cl->DATA);
2376 freechain((chain_list *)scanptype->DATA);
2377 break;
2378 default:
2379 #ifdef MBK_TRACE_BAD_PTYPE
2380 fprintf( stderr, "WARNING in dellosiguser() : unknown ptype %08X\n",
2381 (unsigned int)scanptype->TYPE
2382 );
2383 #endif
2384 break;
2385 }
2386 /*
2387 if( del )
2388 {
2389 if( !prev )
2390 ptlosig->USER = next;
2391 else
2392 prev->NEXT = next;
2393 scanptype->NEXT = NULL;
2394 freeptype( scanptype );
2395 }
2396 else
2397 prev = scanptype;
2398 */
2399 }
2400 freeptype(ptlosig->USER); ptlosig->USER=NULL;
2401 }
2402
2403 void locklofig( lofig_list *ptfig )
2404 {
2405 if( !getptype( ptfig->USER, LOFIG_LOCK ) )
2406 ptfig->USER = addptype( ptfig->USER, LOFIG_LOCK, NULL );
2407 }
2408
2409 void unlocklofig( lofig_list *ptfig )
2410 {
2411 if( getptype( ptfig->USER, LOFIG_LOCK ) )
2412 ptfig->USER = delptype( ptfig->USER, LOFIG_LOCK );
2413 }
2414
2415 int islofiglocked( lofig_list *ptfig )
2416 {
2417 if( getptype( ptfig->USER, LOFIG_LOCK ) ) return 1;
2418 return 0;
2419 }
2420
2421 losig_list* mbk_getlosigbyname( lofig_list *lofig, char *name )
2422 {
2423 losig_list *losig;
2424 chain_list *scan;
2425
2426 name = namealloc( name );
2427
2428 for( losig = lofig->LOSIG ; losig ; losig = losig->NEXT ) {
2429 for( scan = losig->NAMECHAIN ; scan ; scan = scan->NEXT ) {
2430 if( scan->DATA == name )
2431 return losig;
2432 }
2433 }
2434
2435 return( NULL );
2436 }
2437
2438 losig_list* mbk_quickly_getlosigbyname( lofig_list *lofig, char *name )
2439 {
2440 losig_list *losig;
2441 chain_list *scan;
2442 ptype_list *p;
2443 long l;
2444 ht_v2 *h;
2445
2446 if ((name = namefind( name ))==NULL) return NULL;
2447
2448 if ((p=getptype(lofig->USER, LOFIG_QUICK_SIG_HT))==NULL)
2449 {
2450 l=(countchain((chain_list *)lofig->LOSIG)+19)/20;
2451 h=addht_v2(l);
2452 for( losig = lofig->LOSIG ; losig ; losig = losig->NEXT ) {
2453 for( scan = losig->NAMECHAIN ; scan ; scan = scan->NEXT ) {
2454 addhtitem_v2(h, scan->DATA, (long)losig);
2455 }
2456 }
2457 p=lofig->USER=addptype(lofig->USER, LOFIG_QUICK_SIG_HT, h);
2458 }
2459
2460 if ((l=gethtitem_v2((ht_v2 *)p->DATA, name))==EMPTYHT) return NULL;
2461 return (losig_list *)l;
2462 }
2463
2464 // for this one name must be nameallocated
2465 loins_list* mbk_quickly_getloinsbyname( lofig_list *lofig, char *name )
2466 {
2467 loins_list *li;
2468 ptype_list *p;
2469 long l;
2470 ht_v2 *h;
2471
2472 if ((p=getptype(lofig->USER, LOFIG_QUICK_INS_HT))==NULL)
2473 {
2474 l=(countchain((chain_list *)lofig->LOINS)+19)/20;
2475 h=addht_v2(l);
2476 for( li = lofig->LOINS ; li ; li = li->NEXT ) {
2477 addhtitem_v2(h, li->INSNAME, (long)li);
2478 }
2479 p=lofig->USER=addptype(lofig->USER, LOFIG_QUICK_INS_HT, h);
2480 }
2481
2482 if ((l=gethtitem_v2((ht_v2 *)p->DATA, name))==EMPTYHT) return NULL;
2483 return (loins_list *)l;
2484 }
2485
2486 // for this one name must be nameallocated
2487 lotrs_list* mbk_quickly_getlotrsbyname( lofig_list *lofig, char *name )
2488 {
2489 lotrs_list *ptlotrs;
2490 ptype_list *ptuser;
2491 long l;
2492 ht_v2 *h;
2493
2494 if ((ptuser=getptype(lofig->USER, LOFIG_QUICK_TRS_HT))==NULL)
2495 {
2496 l=(countchain((chain_list *)lofig->LOTRS)+19)/20;
2497 h=addht_v2(l);
2498 for( ptlotrs = lofig->LOTRS ; ptlotrs ; ptlotrs = ptlotrs->NEXT ) {
2499 addhtitem_v2(h, ptlotrs->TRNAME, (long)ptlotrs);
2500 }
2501 ptuser=lofig->USER=addptype(lofig->USER, LOFIG_QUICK_TRS_HT, h);
2502 }
2503
2504 if ((l=gethtitem_v2((ht_v2 *)ptuser->DATA, name))==EMPTYHT) return NULL;
2505 return (lotrs_list *)l;
2506 }
2507
2508 int mbk_istranscrypt(char *name)
2509 {
2510 chain_list *ptchain;
2511
2512 // name = namealloc(name);
2513 for (ptchain = CRYPTMOS; ptchain; ptchain = ptchain->NEXT) {
2514 if (ptchain->DATA == name) return 1;
2515 }
2516 return 0;
2517 }
2518
2519 int mbk_istransn(char *name)
2520 {
2521 chain_list *ptchain;
2522
2523 // name = namealloc(name);
2524 for (ptchain = TNMOS; ptchain; ptchain = ptchain->NEXT) {
2525 if (ptchain->DATA == name) return 1;
2526 }
2527 return 0;
2528 }
2529
2530 int mbk_istransp(char *name)
2531 {
2532 chain_list *ptchain;
2533
2534 // name = namealloc(name);
2535 for (ptchain = TPMOS; ptchain; ptchain = ptchain->NEXT) {
2536 if (ptchain->DATA == name) return 1;
2537 }
2538 return 0;
2539 }
2540
2541 char mbk_gettranstype(char *type)
2542 {
2543 if (mbk_istransn(type))
2544 return(TRANSN) ;
2545 else if (mbk_istransp(type))
2546 return(TRANSP) ;
2547 else
2548 return(TRANSN) ;
2549 }
2550
2551 int mbk_isdioden(char *name)
2552 {
2553 chain_list *ptchain;
2554
2555 name = namealloc(name);
2556 for (ptchain = DNMOS; ptchain; ptchain = ptchain->NEXT) {
2557 if (ptchain->DATA == name) return 1;
2558 }
2559 return 0;
2560 }
2561
2562 int mbk_isdiodep(char *name)
2563 {
2564 chain_list *ptchain;
2565
2566 name = namealloc(name);
2567 for (ptchain = DPMOS; ptchain; ptchain = ptchain->NEXT) {
2568 if (ptchain->DATA == name) return 1;
2569 }
2570 return 0;
2571 }
2572
2573 char mbk_getdiodetype(char *type)
2574 {
2575 if (mbk_isdioden(type))
2576 return(TRANSN) ;
2577 else if (mbk_isdiodep(type))
2578 return(TRANSP) ;
2579 else
2580 return(TRANSN) ;
2581 }
2582
2583 int mbk_isjfetn(char *name)
2584 {
2585 chain_list *ptchain;
2586
2587 name = namealloc(name);
2588 for (ptchain = JFETN; ptchain; ptchain = ptchain->NEXT) {
2589 if (ptchain->DATA == name) return 1;
2590 }
2591 return 0;
2592 }
2593
2594 int mbk_isjfetp(char *name)
2595 {
2596 chain_list *ptchain;
2597
2598 name = namealloc(name);
2599 for (ptchain = JFETP; ptchain; ptchain = ptchain->NEXT) {
2600 if (ptchain->DATA == name) return 1;
2601 }
2602 return 0;
2603 }
2604
2605 char mbk_getjfettype(char *type)
2606 {
2607 if (mbk_isjfetn(type))
2608 return(TRANSN) ;
2609 else if (mbk_isjfetp(type))
2610 return(TRANSP) ;
2611 else
2612 return(TRANSN) ;
2613 }
2614
2615 /*******************************************************************************
2616
2617 Fonction de positionnement d'un offset pour l'acces direct dans des fichiers
2618 pour des losig.
2619
2620 *******************************************************************************/
2621
2622 void mbk_losig_setfilepos( lofig_list *lofig,
2623 losig_list *losig,
2624 FILE *file,
2625 MBK_OFFSET_MAX *pos,
2626 long flagtab,
2627 long flagheap
2628 )
2629 {
2630 ptype_list *ptl;
2631 HeapAlloc *heap;
2632 it *look;
2633
2634 MBK_OFFSET_STD offset_std;
2635 MBK_OFFSET_LFS offset_lfs;
2636 MBK_OFFSET_LFS *ptoffset_lfs;
2637
2638 look=NULL;
2639 ptl = getptype( lofig->USER, flagtab );
2640 if( !ptl ) {
2641 look = addit(10);
2642 lofig->USER = addptype( lofig->USER, flagtab, look );
2643 }
2644 else {
2645 look = (it*)ptl->DATA;
2646 }
2647
2648 if( mbk_getfileacces( file ) == MBK_FILE_STD ) {
2649 offset_std = *(MBK_OFFSET_STD*)pos;
2650 setititem( look, losig->INDEX, (long)offset_std );
2651 }
2652 else { //MBK_FILE_LFS
2653
2654 offset_lfs = *(MBK_OFFSET_LFS*)pos;
2655 ptl = getptype( lofig->USER, flagheap );
2656 if( !ptl ) {
2657 heap = mbkalloc( sizeof(HeapAlloc) );
2658 CreateHeap( sizeof(MBK_OFFSET_LFS), 32, heap );
2659 lofig->USER = addptype( lofig->USER, flagheap, heap );
2660 }
2661 else {
2662 ptl = getptype( lofig->USER, flagheap );
2663 heap = (HeapAlloc*)ptl->DATA;
2664 }
2665
2666 ptoffset_lfs = (MBK_OFFSET_LFS*) getititem( look, losig->INDEX );
2667 if( ptoffset_lfs == (MBK_OFFSET_LFS*)EMPTYHT ) {
2668 ptoffset_lfs = AddHeapItem( heap );
2669 setititem( look, losig->INDEX, (long)ptoffset_lfs );
2670 }
2671 *ptoffset_lfs = offset_lfs;
2672 }
2673 }
2674
2675 char mbk_losig_getfilepos( lofig_list *lofig,
2676 losig_list *losig,
2677 FILE *file,
2678 MBK_OFFSET_MAX *pos,
2679 long flagtab
2680 )
2681 {
2682 ptype_list *ptl;
2683 it *look;
2684 MBK_OFFSET_LFS *offset_lfs;
2685 MBK_OFFSET_STD offset_std;
2686
2687 look=NULL;
2688 ptl = getptype( lofig->USER, flagtab );
2689 if( !ptl ) {
2690 look = addit(10);
2691 lofig->USER = addptype( lofig->USER, flagtab, look );
2692 }
2693 else {
2694 look = (it*)ptl->DATA;
2695 }
2696
2697 if( mbk_getfileacces( file ) == MBK_FILE_STD ) {
2698 offset_std = (MBK_OFFSET_STD)getititem( look, losig->INDEX );
2699 if( offset_std == (MBK_OFFSET_STD)EMPTYHT ||
2700 offset_std == (MBK_OFFSET_STD)DELETEHT ){
2701 *(MBK_OFFSET_STD*)pos = (MBK_OFFSET_STD)0;
2702 return 0;
2703 }else{
2704 *(MBK_OFFSET_STD*)pos = offset_std;
2705 return 1;
2706 }
2707 }
2708 else {
2709 offset_lfs = (MBK_OFFSET_LFS*)getititem( look, losig->INDEX );
2710 if( offset_lfs == (MBK_OFFSET_LFS*)EMPTYHT ||
2711 offset_lfs == (MBK_OFFSET_LFS*)DELETEHT ){
2712 *(MBK_OFFSET_LFS*)pos = (MBK_OFFSET_LFS)0;
2713 return 0;
2714 }else{
2715 *(MBK_OFFSET_LFS*)pos = *offset_lfs;
2716 return 1;
2717 }
2718 }
2719 }
2720
2721 void mbk_losig_clearfilepos( lofig_list *lofig,
2722 FILE *file,
2723 long flagtab,
2724 long flagheap
2725 )
2726 {
2727 ptype_list *ptl;
2728
2729 ptl = getptype( lofig->USER, flagtab );
2730 if( ptl ) {
2731 delit( (it*)ptl->DATA );
2732 lofig->USER = delptype( lofig->USER, flagtab );
2733 }
2734
2735 ptl = getptype( lofig->USER, flagheap );
2736 if( ptl ) {
2737 DeleteHeap( (HeapAlloc*)ptl->DATA );
2738 mbkfree( ptl->DATA );
2739 lofig->USER = delptype( lofig->USER, flagheap );
2740 }
2741
2742 file=NULL; //unused parameter.
2743 }
2744
2745 void mbkSwitchContext(mbkContext *ctx)
2746 {
2747 ht *tempht;
2748 lofig_list *temphead;
2749 tempht=HT_LOFIG;
2750 temphead=HEAD_LOFIG;
2751 HT_LOFIG=ctx->HT_LOFIG;
2752 HEAD_LOFIG=ctx->HEAD_LOFIG;
2753 ctx->HT_LOFIG=tempht;
2754 ctx->HEAD_LOFIG=temphead;
2755 }
2756
2757 mbkContext *mbkCreateContext()
2758 {
2759 mbkContext *ctx=(mbkContext *)mbkalloc(sizeof(mbkContext));
2760 ctx->HT_LOFIG=addht(100);
2761 ctx->HEAD_LOFIG=NULL;
2762 return ctx;
2763 }
2764
2765 void mbkFreeContext(mbkContext *ctx)
2766 {
2767 mbkfree(ctx);
2768 }
2769
2770 void mbkFreeAndSwitchContext(mbkContext *ctx)
2771 {
2772 mbkSwitchContext(ctx);
2773 delht(ctx->HT_LOFIG);
2774 mbkfree(ctx);
2775 }
2776
2777 /*******************************************************************************
2778 * Power Supply Marking Functions *
2779 *******************************************************************************/
2780
2781 int mbk_MarkAlim(losig_list *ls)
2782 {
2783 long flags=0;
2784 chain_list *ch;
2785 float value;
2786
2787 if (getlosigalim(ls, &value))
2788 {
2789 if ((long)(value*SCALE_ALIM + 0.5) > VDD_VSS_THRESHOLD) flags|=MBK_ALIM_VDD_FLAG;
2790 else flags|=MBK_ALIM_VSS_FLAG;
2791 }
2792
2793 for (ch=ls->NAMECHAIN; ch!=NULL; ch=ch->NEXT)
2794 {
2795 // type yagle
2796 if (ls->TYPE=='D') flags|=MBK_ALIM_VDD_FLAG;
2797 else if (ls->TYPE=='S') flags|=MBK_ALIM_VSS_FLAG;
2798 // ----
2799 if (isvss((char *)ch->DATA)) flags|=MBK_ALIM_VSS_FLAG;
2800 if (isvdd((char *)ch->DATA)) flags|=MBK_ALIM_VDD_FLAG;
2801 if (isglobalvss((char *)ch->DATA)) flags|=MBK_ALIM_VSS_FLAG|MBK_HAS_GLOBAL_NODE_FLAG;
2802 if (isglobalvdd((char *)ch->DATA)) flags|=MBK_ALIM_VDD_FLAG|MBK_HAS_GLOBAL_NODE_FLAG;
2803 }
2804
2805 ls->ALIMFLAGS&=~(MBK_ALIM_VSS_FLAG|MBK_ALIM_VDD_FLAG);
2806 ls->ALIMFLAGS|=flags|MBK_SIGNAL_ALIM_DONE_FLAG;
2807
2808 return flags;
2809 }
2810
2811 void mbk_MarkLofig(lofig_list *lf)
2812 {
2813 losig_list *ls;
2814 for (ls=lf->LOSIG; ls!=NULL; ls=ls->NEXT)
2815 mbk_MarkAlim(ls);
2816 }
2817
2818 int mbk_GetAlimFlags(losig_list *ls)
2819 {
2820 if ((ls->ALIMFLAGS & MBK_SIGNAL_ALIM_DONE_FLAG)==0)
2821 mbk_MarkAlim(ls);
2822 return ls->ALIMFLAGS;
2823 }
2824
2825 int mbk_LosigIsVDD(losig_list *ls)
2826 {
2827 if ((ls->ALIMFLAGS & MBK_SIGNAL_ALIM_DONE_FLAG)==0)
2828 mbk_MarkAlim(ls);
2829 return (ls->ALIMFLAGS & MBK_ALIM_VDD_FLAG)!=0;
2830 }
2831
2832 int mbk_LosigIsVSS(losig_list *ls)
2833 {
2834 if ((ls->ALIMFLAGS & MBK_SIGNAL_ALIM_DONE_FLAG)==0)
2835 mbk_MarkAlim(ls);
2836 return (ls->ALIMFLAGS & MBK_ALIM_VSS_FLAG)!=0;
2837 }
2838
2839 int mbk_LosigIsGlobal(losig_list *ls)
2840 {
2841 return (ls->ALIMFLAGS & MBK_HAS_GLOBAL_NODE_FLAG)!=0;
2842 }
2843
2844 void mbk_SetLosigVDD(losig_list *ls)
2845 {
2846 ls->ALIMFLAGS&=~(MBK_ALIM_VSS_FLAG|MBK_ALIM_VDD_FLAG);
2847 ls->ALIMFLAGS |= (MBK_ALIM_VDD_FLAG|MBK_SIGNAL_ALIM_DONE_FLAG);
2848 }
2849
2850 void mbk_SetLosigVSS(losig_list *ls)
2851 {
2852 ls->ALIMFLAGS&=~(MBK_ALIM_VSS_FLAG|MBK_ALIM_VDD_FLAG);
2853 ls->ALIMFLAGS |= (MBK_ALIM_VSS_FLAG|MBK_SIGNAL_ALIM_DONE_FLAG);
2854 }
2855
2856 /*##------------------------------------------------------------------##*/
2857 /* Function : duplosigalim() */
2858 /*##------------------------------------------------------------------##*/
2859
2860 void duplosigalim (losig_ptr, losig_rpt)
2861 losig_list *losig_ptr;
2862 losig_list *losig_rpt;
2863 {
2864 float alim=0;
2865 char *expr;
2866
2867 expr=getlosigalim_expr(losig_ptr);
2868 if (getlosigalim (losig_ptr, &alim) || expr!=NULL)
2869 addlosigalim (losig_rpt, alim, expr);
2870 }
2871
2872 void mbk_copylosiginfo(losig_list *source, losig_list *dest)
2873 {
2874 duplosigalim (source, dest);
2875 dest->ALIMFLAGS=source->ALIMFLAGS;
2876 }
2877
2878 /*******************************************************************************
2879 * function addlosigalim *
2880 *******************************************************************************/
2881 void addlosigalim(losig_list *losig, float alim, char *expr)
2882 {
2883 ptype_list *ptype ;
2884 long lalim ;
2885
2886
2887 if (expr!=NULL)
2888 {
2889 if((ptype = getptype(losig->USER,LOSIGALIM_EXPR)) == NULL)
2890 losig->USER = addptype(losig->USER,LOSIGALIM_EXPR,expr) ;
2891 else
2892 {
2893 avt_errmsg (MBK_ERRMSG, "035", AVT_WARNING, getsigname(losig));
2894 ptype->DATA = expr;
2895 }
2896 }
2897 else
2898 {
2899 lalim = (long)(SCALE_ALIM * alim + 0.5) ;
2900
2901 if((ptype = getptype(losig->USER,LOSIGALIM)) == NULL)
2902 losig->USER = addptype(losig->USER,LOSIGALIM,(void *)lalim) ;
2903 else
2904 {
2905 avt_errmsg (MBK_ERRMSG, "035", AVT_WARNING, getsigname(losig));
2906 ptype->DATA = (void *)lalim ;
2907 }
2908 /* Add the Supply Marks */
2909 mbk_MarkAlim(losig);
2910 }
2911 }
2912
2913 /*******************************************************************************
2914 * function dellosigalim *
2915 *******************************************************************************/
2916 int dellosigalim(losig_list *losig)
2917 {
2918 if(getptype(losig->USER,LOSIGALIM) != NULL)
2919 {
2920 losig->USER = delptype(losig->USER,LOSIGALIM) ;
2921 return 1 ;
2922 }
2923
2924 return 0 ;
2925 }
2926 void dellosigalim_expr(losig_list *losig)
2927 {
2928 if(getptype(losig->USER,LOSIGALIM_EXPR) != NULL)
2929 {
2930 losig->USER = delptype(losig->USER,LOSIGALIM_EXPR) ;
2931 }
2932 }
2933
2934 /*******************************************************************************
2935 * function getlosigalim *
2936 *******************************************************************************/
2937 int getlosigalim(losig_list *losig, float *alim)
2938 {
2939 ptype_list *ptype ;
2940 long lalim ;
2941
2942 if((ptype = getptype(losig->USER,LOSIGALIM)) != NULL)
2943 {
2944 lalim = (long)ptype->DATA ;
2945 if ( alim )
2946 *alim = (float)lalim / SCALE_ALIM ;
2947 return 1 ;
2948 }
2949
2950 return 0 ;
2951 }
2952 char *getlosigalim_expr(losig_list *losig)
2953 {
2954 ptype_list *ptype ;
2955
2956 if((ptype = getptype(losig->USER,LOSIGALIM_EXPR)) != NULL)
2957 return (char *)ptype->DATA;
2958
2959 return NULL ;
2960 }
2961
2962 lofiginfo *mbk_getlofiginfo(lofig_list *lf, int create)
2963 {
2964 ptype_list *pt;
2965 lofiginfo *lfif;
2966 pt=getptype(lf->USER, LOFIG_INFO);
2967 if (pt==NULL)
2968 {
2969 if (!create) return NULL;
2970 }
2971 else return (lofiginfo *)pt->DATA;
2972 lfif=mbkalloc(sizeof(lofiginfo));
2973 // init
2974 lfif->scale=1;
2975 //
2976 lf->USER=addptype(lf->USER, LOFIG_INFO, lfif);
2977 return lfif;
2978 }
2979
2980 int mbk_can_cross_transistor_to(losig_list *ls, lotrs_list *tr, char dir)
2981 {
2982 locon_list *from, *to;
2983 long flagfrom, flagto, testfrom, testto;
2984 ptype_list *pt;
2985 if (ls==tr->SOURCE->SIG) from=tr->SOURCE, to=tr->DRAIN;
2986 else to=tr->SOURCE, from=tr->DRAIN;
2987 if ((pt=getptype(from->USER, LOCON_INFORMATION))==NULL) flagfrom=0;
2988 else flagfrom=(long)pt->DATA;
2989 if ((pt=getptype(to->USER, LOCON_INFORMATION))==NULL) flagto=0;
2990 else flagto=(long)pt->DATA;
2991
2992 if (dir=='i') testfrom=LOCON_INFORMATION_OUTPUT, testto=LOCON_INFORMATION_INPUT;
2993 else testfrom=LOCON_INFORMATION_INPUT, testto=LOCON_INFORMATION_OUTPUT;
2994
2995 if (flagfrom!=0 && (flagfrom & testfrom)==0) return 0;
2996 if (flagto!=0 && (flagto & testto)==0) return 0;
2997 return 1;
2998 }
2999
3000 void mbk_debug_losig( char *label, lofig_list *lofig )
3001 {
3002 losig_list *ls;
3003 char *name;
3004 if ((name=getenv("MBK_DEBUG_LOSIG"))!=NULL)
3005 {
3006 ls= mbk_quickly_getlosigbyname( lofig,namealloc(name) );
3007 printf("debug_losig (%s) %s:\n", label, name);
3008 if (ls!=NULL)
3009 viewlosig_sub(ls,1);
3010 else
3011 printf("signal not found\n");
3012 }
3013 }